דלגו לתוכן הראשי
8200 University Pro

קוד הסדנה בגאמ"א סייבר: OOP, בלאק בוקס וההגנה בראיון

המאמר הזה הוא המשך טכני למאמר הסדנה המעשית, ולא חזרה עליו. שם מוסבר מבנה הסדנה ושני המסלולים שלה. כאן יורדים שלב אחד עומק לתוך שלושה דברים קונקרטיים: איך נראית ארכיטקטורה שבאמת סופגת דרישות שמשתנות תוך כדי, מה קורה בפועל בשלוש השכבות של אתגר הקופסה השחורה, ואיך מגינים על הקוד שכתבתם כשהמראיין פותח אותו שוב שבועות אחר כך.

הערה על הנתונים: צה"ל אינו מפרסם רשמית את תוכן המשימות, מבנה אתגר הבלאק בוקס או שיטת ההערכה בראיון. הפירוט כאן מבוסס על דיווחי מועמדים ועל עקרונות פיתוח ואבטחה כלליים, ועשוי להשתנות בין מחזורי גיוס. התייחסו אליו ככיוון להכנה ולא כמפרט מדויק.

המאמר הזה הוא חלק מהמדריך המלא למיוני גאמ"א סייבר. אם עוד לא קראתם את מאמר הסדנה המעשית, כדאי להתחיל משם ולחזור לכאן.

כש"הדרישות משתנות" זה ממש קורה: ארכיטקטורה שעומדת בלחץ

נניח שקיבלתם פרויקט מדורג: מערכת מלאי של יבואן רכב, או מערכת שקוראת רשומות נתונים ומעבדת אותן. מועמד שממהר כותב מחלקה אחת גדולה שעושה הכל בפונקציה קשיחה אחת: קוראת קובץ, מפענחת אותו, ומנהלת את המלאי, בלי שום הפרדה בין השלבים.

ואז מגיעים שלבים 3 עד 5. בגרסת המלאי: המלאי הופך מוגבל, מתבקשת הוספה של תור למחסן שטיפה, ותמחור האביזרים הופך דינמי. בגרסת הנתונים: הקלט עובר בשלב 3 מקובץ טקסט מקומי לסוקט TCP, ובשלב 4 הופך לפורמט בינארי מוצפן ב-XOR. מועמד שכתב הכל במחלקה אחת צריך לשכתב אותה בכל שלב. מועמד שהפריד בין המקור, הפענוח והלוגיקה מחליף רכיב אחד בלבד.

הפתרון הוא לא "לכתוב קוד טוב יותר" באופן מעורפל, אלא עיקרון קונקרטי: להפריד בין ממשקים מהדקה הראשונה, לפי עקרון הפתיחות-סגירות, אחד מחמשת עקרונות SOLID בתכנון תוכנה (Open/Closed Principle), בעזרת תבנית Strategy והזרקת תלויות (Dependency Injection). במקום שהמחלקה המרכזית תדע איך קוראים את הקובץ ואיך מפענחים אותו, היא מקבלת רכיבים שמיישמים ממשק מוגדר, ורק קוראת להם.

איך זה נראה בקוד

שלושה ממשקים נפרדים, ומחלקת מנוע שלא מכירה אף מימוש קונקרטי שלהם, רק את החוזה:

from abc import ABC, abstractmethod

class IDataSource(ABC):  # המקור: קובץ מקומי, סוקט, כל דבר שמחזיר בייטים גולמיים
    @abstractmethod
    def read_raw(self) -> bytes:
        pass

class IDecoderLayer(ABC):  # הפענוח: XOR, בסיס 64, או כל קידוד שיתווסף בהמשך
    @abstractmethod
    def decode(self, raw_data: bytes) -> bytes:
        pass

class IPacketParser(ABC):  # הפירוק: טקסט רגיל, JSON, או פורמט בינארי קשיח
    @abstractmethod
    def parse(self, clean_data: bytes) -> dict:
        pass

class WorkshopProcessingEngine:
    def __init__(self, source: IDataSource, decoder: IDecoderLayer, parser: IPacketParser):
        self.source = source
        self.decoder = decoder
        self.parser = parser

    def execute_cycle(self) -> dict:
        raw = self.source.read_raw()        # שלב 1: קריאה, לא משנה מאיפה
        decoded = self.decoder.decode(raw)   # שלב 2: פענוח, לא משנה איך
        return self.parser.parse(decoded)    # שלב 3: פירוק למבנה נתונים

כשהקלט עובר בשלב 3 מקובץ לסוקט, רק המימוש של IDataSource מתחלף; IDecoderLayer, IPacketParser ומחלקת WorkshopProcessingEngine לא נוגעים כלל. כשמתווסף קידוד XOR בשלב 4, מוסיפים מימוש חדש לIDecoderLayer, ולא משנים שורה אחת בקוד הקיים. זו בדיוק ההבטחה של עקרון הפתיחות-סגירות: פתוח להרחבה, סגור לשינוי.

הנקודה שחשוב להפנים: כשהבוחן ניגש למחשב שלכם בסוף כל שלב, הוא לא קורא רק אם הפלט נכון. הוא קורא את הקוד ומחפש הפרדת אחריות: האם מחלקה אחת עושה דבר אחד, והאם שינוי בדרישה דורש להוסיף קוד או לשכתב קוד קיים. זו בדיוק המלכודת שמאמר הסדנה המעשית מתאר: מהירות בשלב הראשון שעולה שעות בהמשך. הארכיטקטורה הזו היא התשובה הקונקרטית לאותה מלכודת.

רוצים לתרגל הפרדת ממשקים לפני הסדנה?

באתר גאמא קוד יש תרגילי תכנות בשלוש רמות קושי, עם בודק אוטומטי והסבר אחרי פתרון. זו הדרך לתרגל את התחושה של לכתוב מחלקה שלא יודעת מי קורא לה, לפני שהשעון רץ.

אתר אחות: gamacode.co.il

שלוש השכבות של אתגר הקופסה השחורה

אם מאמר הסדנה המעשית נתן את ארגז הכלים הכללי, כאן יש פירוק לשלוש החזיתות שבאמת נפתחות בתוך אתגר כזה. לא כל שלב נופל בשכבה אחת, ולפעמים המעבר בין שכבות הוא בדיוק התובנה שמקדמת אתכם.

שכבה 1: מערכת ההפעלה והפנים הבינארי

שכבה 2: הנדסה לאחור של תעבורת הרשת

שכבה 3: ניצול פרצות Web

רוב אתגרי הבלאק בוקס לא נשארים בשכבה אחת. מחרוזת שחולצה משכבה 1 יכולה להיות הסיסמה שמנסים מול טופס שכבה 3, ותעבורה שנלכדה בשכבה 2 יכולה לחשוף את הנתיב הסודי שמוביל לשם. המעבר המודע בין השכבות הוא בדיוק מה שמבדיל פתרון מהיר מתקיעות של שעות.

רוצים להתנסות בבלאק בוקס אמיתי, בחינם?

ב8200university.co.il יש דמו בלאק בוקס חינמי: מערכת הפעלה מבוססת לינוקס שנבנתה במיוחד לתרגול, עם סרטון הסבר קצר בפתיחה מהמרצה הראשי, וארבעה אתגרים נפרדים לפיצוח: lotr, hogwarts, marvel וcyberwars. זה לא סימולציה מדויקת של הסדנה, אבל זו ההתנסות המעשית הקרובה ביותר שיש לפני היום עצמו.

לדמו הבלאק בוקס החינמי (נפתח בכרטיסייה חדשה)

(אתר חיצוני, לא חלק מהאתר הזה)

תיעוד בזמן אמת, ולמה ההגנה בראיון היא חלק מהמבחן

לפי דיווחי מועמדים כמעט אף אחד לא מסיים את עשרת שלבי הבלאק בוקס. איפה שעצרתם ואיך תיעדתם את הדרך משפיעים כמעט כמו עד כמה שהתקדמתם. הדרך הפשוטה ביותר: קובץ טקסט פתוח על שולחן העבודה, מתעדכן תוך כדי עבודה, בטבלה עם חמש עמודות.

עמודהדוגמה למילוי
מטרת השלב הנוכחילזהות למה הפלט משתנה כשהקלט עובר 16 תווים
תצפיות וטלמטריהקלט של 15 תווים מחזיר שגיאה A, קלט של 16 מחזיר שגיאה B
השערות שנבדקו ונפסלוהצפנה נפסלה; זה כנראה שדה אורך בבייט הראשון
היגיון פנימי שהוסקהפורמט הוא בייט אורך ואז מטען; שינוי בביט אחד אישר את זה
תוכנית ל-30 הדקות הבאותלנסות קלט של 17 ו-32 תווים ולבדוק אם השדה משתנה בהתאם

אחרי כמה שעות של ניסויים ותקיעות קל לאבד את החוט: מה כבר נבדק, מה נפסל ולמה. הטבלה הזו היא מה שמאפשר לכם לחזור בדיוק לנקודה שעצרתם בה, בלי לחפור מחדש באדמה שכבר נחרשה.

שבועות אחר כך: המראיין פותח את הקוד שלכם

מאמר הראיונות מפרט את שיטת הדחיפה לקצה הידע ואת שני מסלולי המיון, הטכני והפסיכולוגי. הנקודה הספציפית כאן היא ההגנה על קוד הסדנה עצמו, והיא נראית קצת אחרת בין המסלולים: בראיונות שנוטים לכיוון 8200 מרכז הכובד נשען יותר על מחקר פרצות, רשתות, מערכות הפעלה ואלגוריתמים; בראיונות שנוטים לכיוון יחידה 81 מרכז הכובד נשען יותר על הפרויקט האישי שלכם ועל הבנה עמוקה בשכבה הנמוכה של הקוד שכתבתם בעצמכם. בשני המקרים, הקוד שעצרתם בו הוא נקודת המוצא.

המראיין פותח את הקוד שהגעתם אליו, ולא שואל רק "איך עבד". הוא מבקש להרחיב אותו בזמן אמת: "נניח שמתווספת עכשיו דרישה חדשה, מה משתנה בתכנון שלך?" או "תראה לי איך היית מתקן את החלק הזה". מה שעובד הוא לחשוב בקול: לנרמל כל הנחה, להסביר כל שיקול, ולהצדיק את הבחירה דווקא ולא בחירה אחרת.

הכלל שחוזר גם במאמר הראיונות: לעולם לא לבלף תשובה שלא ידועה. "את זה אני לא יודע, אבל הייתי בודק ככה" היא תשובה טובה. מראיין שראה מאות מועמדים מזהה בלוף כמעט מיד, וזה פוגע באמינות הרבה יותר מאשר הודאה פשוטה בפער ידע.

סיכום

שלושה דברים נפרדים נפגשים כאן, וכולם נבדקים אחרי שהקוד כבר רץ: ארכיטקטורה שמפרידה בין ממשקים כך שדרישה חדשה היא הוספה ולא שכתוב, יכולת לנווט בין שלוש השכבות של אתגר הבלאק בוקס בלי להיתקע באחת מהן, ותיעוד מסודר שמאפשר להגן בראיון על כל שורת קוד שכתבתם, כולל ההחלטות שבדיעבד הייתם משנים.

למי שרוצה רקע קצר על העיקרון שבבסיס החלק הראשון של המאמר, הערך תכנות מונחה עצמים בוויקיפדיה נותן את אוצר המילים הבסיסי: מחלקות, ממשקים והפרדת אחריות. אף אחד לא מצפה מכם להגיע לסדנה כמומחים בתבניות עיצוב, אבל מי שמכיר את המושגים האלה כותב את הקוד שלב 1 נכון מההתחלה, ולא רק שלב 4.

השלב הבא בתהליך, אחרי הסדנה: ראיונות, מבחן TAT וסיווג ביטחוני.

שאלות נפוצות

למה דרישות משתנות באמצע הסדנה הן בכלל חלק מהמבחן?

כי זה בדיוק מה שקורה בפיתוח אמיתי. מסלול הפיתוח משוחרר במנות: מקבלים דרישות שלב, מממשים, בוחן בודק, ורק אז משתחררות דרישות השלב הבא. ארכיטקטורה שמפרידה בין מקור הנתונים, הפענוח והלוגיקה סופגת שינוי כזה בלי שכתוב; קוד שכתוב בפונקציה אחת גדולה נשבר בכל שלב חדש.

מה ההבדל בין שלוש השכבות של אתגר הבלאק בוקס?

שכבה אחת היא מערכת ההפעלה והקובץ הבינארי עצמו: מה שרואים בעורך בינארי, בחילוץ מחרוזות או בקובץ hosts. שכבה שנייה היא תעבורת הרשת: מה שעובר בין תהליכים ונתפס בכלי כמו Wireshark. שכבה שלישית היא ממשק web: מה שנגיש מהדפדפן, מ-DevTools ועד פרצות הזרקה. אתגר שלם לרוב דורש לעבור בין שלוש השכבות ולא להישאר באחת.

איך בודקים זריקת SQL מבוססת זמן בלי כלים יקרים?

עם סקריפט Python קטן ומודול הבקשות הסטנדרטי. שולחים קלט שגורם לשרת להשתהות אם תנאי מתקיים (למשל תו ראשון בסיסמה), מודדים זמן תגובה, וחוזרים על זה תו אחר תו. זה כלי ביתי, לא מוצר מסחרי, וזה בדיוק מה שהאתגר בוחן: האם אתם מבינים את העיקרון ולא רק מכירים שם של כלי.

מה קרה אם לא סיימתי את כל שלבי הבלאק בוקס עד סוף היום?

לפי דיווחי מועמדים כמעט אף אחד לא מסיים, וזה חלק מהתכנון. מה שממשיך להיבדק אחרי הסדנה הוא התיעוד שהשארתם ואיך אתם מגינים על הקוד שכתבתם בראיון, לא רק כמה שלבים פתרתם. ראו את מאמר הראיונות לפירוט על שיטת הדחיפה לקצה הידע.

להגיע עם בסיס יציב בלינוקס, C ורשתות

שלוש השכבות של אתגר הבלאק בוקס נשענות על לינוקס, שפת C והבנה בסיסית של תעבורת רשת. בגאמא קוד אפשר לתרגל את שני הנושאים הראשונים לפי תתי נושאים וברמות קושי, עם הסבר לכל שאלה.

אתר אחות: gamacode.co.il