קוד הסדנה בגאמ"א סייבר: 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: מערכת ההפעלה והפנים הבינארי
- שורת הפקודה והרישום. cmd וPowerShell של Windows, וחיפוש בRegistry אחרי מפתח שמעיד על הגדרה חבויה.
- קובץ ה-hosts. לפעמים ממופה בו תת-דומיין סודי לכתובת פנימית שאף שרת שמות לא מכיר.
- זיהוי לפי בייטים פותחים. בעורך בינארי (hex editor) בודקים את הכותרת של קובץ, לא את הסיומת שלו:
89504E47הוא PNG,25504446הוא PDF, ו504B0304הוא ZIP. קובץ עם סיומת אחת וכותרת אחרת הוא לרוב הרמז. - חילוץ מחרוזות. הרצת חילוץ מחרוזות על קובץ EXE או ELF חושפת לא פעם סיסמה או מפתח API ששכחו להוריד לפני שהעתיקו את הקובץ לתיקיית האתגר.
שכבה 2: הנדסה לאחור של תעבורת הרשת
- לכידת תעבורה. Wireshark על קובץ PCAP נתון, ולא רק ניטור חי.
- Follow TCP Stream. שחזור שיחה שלמה חושף לא פעם שם משתמש וסיסמה שעברו בטקסט גלוי מעל HTTP, FTP או Telnet, פרוטוקולים שלא מצפינים כלום.
- הדלפת מידע בשאילתות שם. שאילתות DNS חריגות באורך או בתדירות, או שדה בכותרת חבילה שלא תואם את מה שמצופה ממנה, מעידים על הוצאת מידע בדרך עקיפה.
שכבה 3: ניצול פרצות Web
- בדיקת המקור. DevTools (F12) לבדיקת קוד המקור, ובדיקת
robots.txtוsitemap.xmlלנתיבים שלא קישרו אליהם מהדף עצמו. - הזרקת SQL מבוססת זמן. כשהתשובה לכל קלט נראית זהה, בודקים השהיה: קלט כמו
' OR IF(SUBSTRING(password,1,1)='A', SLEEP(5), 0)--גורם לשרת להשתהות אם התו הראשון בסיסמה הוא "A". מריצים את הבדיקה בלולאה על כל התווים האפשריים בסקריפט Python קטן עם מודול requests, ולא ידנית אחד-אחד. - הזרקת תבנית בצד השרת (SSTI). אם האתר בנוי על Flask ו-Jinja2, בדיקה פשוטה כמו
{{ 7*7 }}בשדה קלט שמוחזר בתשובה: אם הוא חוזר כ-49 ולא כמחרוזת גולמית, מנוע התבניות מריץ את הקלט, וזה פתח להרצת פקודות. - מניפולציה ב-JWT. בדיקה של הרשאה: האם אפשר לשנות שדה תפקיד ממשתמש רגיל למנהל ולקבל אותו מאומת, או שהשרת מקבל גם אסימון עם
"alg":"none"בלי לבדוק חתימה בכלל.
רוב אתגרי הבלאק בוקס לא נשארים בשכבה אחת. מחרוזת שחולצה משכבה 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