פרוטוקול תקשורת מומצא

תכנות, אלגוריתמיקה ו-Web · 5–6 שעות

⌨ כתיבת קוד (2)תרגילים ומשימות קוד לשיעור 13

// סקירה

שיעור 13: פרוטוקול תקשורת מומצא

מבחן הפרוטוקול = 15–20 שאלות ב-30–40 דקות. מקבלים מפרט + Packets בHex ושואלים: "מה שגוי?", "חשב Checksum", "צור Packet חוקי". אותה מתודולוגיה כמו שפה מומצאת — 5 שלבים.

✓נושאי שיעור 13 — פרוטוקולים

מבנה Packet: Header, Payload, Checksum, Flags
חישוב Checksum: XOR, SUM%256, Two's Complement
Flags ו-Bitmask Operations
State Machine — מצבי חיבור ומעברים חוקיים
StreamLink (בסיסי) · DataPlex (בינוני) · SecureQ (מתקדם)
5 שלבים לפרוטוקול מומצא — כמו 5 השלבים לשפה

// מבוא

פרוטוקול תקשורת מומצא

מבחן הפרוטוקול = 15–20 שאלות ב-30–40 דקות. מקבלים מפרט + Packets בHex. שואלים: "מה שגוי?", "חשב Checksum", "מה שדה X?", "צור Packet חוקי". אותה מתודולוגיה כמו שפה מומצאת — 5 שלבים.

💡 אנלוגיה — Packet כמעטפה

מכתב שנשלח בדואר: מעטפה (Header) עם כתובת שולח/נמען, תוכן (Payload), חותמת (Checksum). Header = מידע על ה-Packet. Payload = המידע עצמו. Checksum = בדיקת תקינות. Flags = bits שמסמנים מצבים.

5 שלבים לפרוטוקול מומצא

שלב	שם	מה עושים	זמן
1	סקר מהיר	קרא כל המפרט פעם אחת. מה סוגי ה-Packets?	4–5 דקות
2	מיפוי Header	ציר: מה כל byte? מאיזה offset? ערכים אפשריים?	3–4 דקות
3	Checksum	הבן האלגוריתם. תרגל חישוב ידני על הדוגמה.	3 דקות
4	Packet Example	מצא דוגמה. פרסר שדה-שדה. ודא הבנה.	3 דקות
5	שאל ענה	לכל שאלה: מצא בMפרט, חשב, בדוק כל שדה	2–3 דקות

Header Fields שחוזרים בכל פרוטוקול

שדה	תיאור	גודל
Magic/Sync	ערך קבוע שמאמת "זה ה-Packet הנכון"	1–2 byte
Type	סוג ה-Packet: SYN, DATA, ACK, FIN...	1 byte
Sequence Number	מספר רציפות — לסדר Packets	1–4 byte
Payload Length	גודל ה-Payload בbytes	1–2 byte
Flags	Bits בודדים למצבים: URGENT, ACK, SYN...	1–2 byte
Checksum	בדיקת שלמות נתונים	1–2 byte

⚠️ Big-Endian vs Little-Endian

פרוטוקולי רשת = Big-Endian (byte גבוה קודם). הערך 0x1234 ב-2 bytes: Big-Endian = 12 34 · Little-Endian = 34 12. כשמפרט אומר "Length=0x0010" = 16 bytes.

✏תרגול — מבוא פרוטוקולים3 שאלות

תרגול 13.1

מה Magic byte? למה הוא קיים?

✓ תשובה: ג) — Magic = sentinel ידוע. מקבל בודק: Magic=0x5A? כן→ זה StreamLink. לא→ זרוק. מונע עיבוד של data רנדומי כ-Packet.

תרגול 13.2

מה ההבדל בין Checksum שגוי ל-Packet לא חוקי (Invalid)?

✓ תשובה: ג) — Checksum שגוי = נתון תקין שנפגם בשידור. Invalid = הPacket עצמו בנוי לא לפי כללי המפרט. שתי שגיאות שונות!

תרגול 13.3

DataPlex: SYN(Seq=10) → SYN-ACK(Seq=50,Ack=?). מה Ack?

✓ תשובה: ב) 11 — Ack = Seq_received + 1 = 10+1 = 11. "קיבלתי Seq=10, מצפה לSeq=11."

// Checksum + Flags

Checksum וFlags: חישוב ידני

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

3 סוגי Checksum

סוג	חישוב	אימות
XOR Checksum	XOR כל הbytes יחד	XOR כולל Checksum = 0
SUM % 256	סכום כל הbytes mod 256	SUM (כולל Checksum) mod 256 = 0
Two's Complement	(256 - sum) % 256	sum + checksum = 0 mod 256

XOR Checksum — חישוב ידני

// XOR כל הbytes:
// Payload = [0x41, 0x42, 0x43]
  0x41 XOR 0x42 = 0x03
  0x03 XOR 0x43 = 0x40
Checksum = 0x40

// Python: cs=0; for b in data: cs^=b

📝 תרגול: [0x12, 0x34, 0x56, 0x78]

0x12 XOR 0x34 = 0x26 · 0x26 XOR 0x56 = 0x70 · 0x70 XOR 0x78 = 0x08

Flags: Bit Manipulation

// Flags byte = 0x0A = 0b00001010
// bit1=ACK=1, bit3=SYN=1
IS_SET(flags, n) = (flags >> n) & 1
SET_bit(flags, n) = flags | (1 << n)
CLR_bit(flags, n) = flags & ~(1 << n)

✏תרגול — Checksum ו-Flags4 שאלות

תרגול 8.1

חשב XOR Checksum: [0xFF, 0x00, 0xAA, 0x55]

✓ תשובה: ד) 0x00 — FF XOR 00=FF, FF XOR AA=55, 55 XOR 55=00.

תרגול 8.2

StreamLink Flags=0x06. מה דולק? (bit0=URGENT, bit1=ENCRYPTED, bit2=LAST)

✓ תשובה: ג) — 0x06=0110: bit0=0, bit1=1=ENCRYPTED, bit2=1=LAST.

תרגול 8.3

Flags byte: URGENT דולק (bit0), LAST דולק (bit2), ENCRYPTED כבוי. מה הערך?

✓ תשובה: א) 0x05 — bit0=1, bit1=0, bit2=1 → 0b00000101 = 0x05.

תרגול 8.4 — XOR Auth

SecureQ RESPONSE: token=0x2B, secret=0x7F. מה Payload?

✓ תשובה: ב) 0x54 — 0x2B XOR 0x7F: 0010 1011 XOR 0111 1111 = 0101 0100 = 0x54

// StreamLink

פרוטוקול StreamLink

הפרוטוקול הבסיסי — 6 bytes Header, XOR Checksum, State Machine פשוט.

📡 StreamLink v1.0 — מפרט

Header (6B): Magic(5A) | Type(01-04,FF) | Seq | PayLen | Flags | Checksum
Flags: bit0=URGENT, bit1=ENCRYPTED, bit2=LAST, bits3-7=0
Checksum = XOR(bytes 0-4, all payload bytes)
Rules: PayLen≤128, Reserved flags=0, Magic=5A always
State: IDLE→(HELLO)→CONNECTED→(DATA)→CONNECTED→(BYE)→IDLE

ניתוח Packets

// Packet A: 5A 01 00 00 00 5B  (HELLO)
Checksum: 5A^01^00^00^00 = 5B ✓ Valid

// Packet B: 5A 02 01 05 04 1A | payload: Hello(48 65 6C 6C 6F)
Type=DATA, Seq=1, PayLen=5, Flags=0x04=LAST
Checksum: 5A^02^01^05^04^48^65^6C^6C^6F = 0x1A ✓

// Packet C: 5A 03 01 00 00 5B  (ACK — Checksum ERROR!)
Expected: 5A^03^01^00^00 = 0x58 ≠ 5B ← ❌

בניית Packet חוקי

📝 DATA עם Payload="Hi", Seq=5, Flags=URGENT+LAST

Magic=5A, Type=02, Seq=05, PayLen=02, Flags=0x05
Checksum: 5A^02^05^02^05^48^69 = 0x7B
→ Packet: 5A 02 05 02 05 7B 48 69

✏תרגול — StreamLink3 שאלות

תרגול 9.1

StreamLink Header: 5A 01 03 00 00. מה Checksum?

✓ 0x58 — 5A^01=5B, ^03=58, ^00=58, ^00=58.

תרגול 9.2 — State Machine

Sequence: HELLO → DATA → BYE → DATA. מה שגוי?

✓ תשובה: ב) — BYE→IDLE. DATA ב-IDLE = Invalid Transition!

תרגול 9.3 — Magic שגוי

Magic=0x5B (במקום 0x5A). כמה שגיאות?

✓ תשובה: א) — Magic≠0x5A → validation fail. Magic חלק מחישוב XOR → Checksum שגוי גם.

// DataPlex + SecureQ

DataPlex ו-SecureQ

DataPlex = Reliable Transfer עם 3-way Handshake ו-NACK. SecureQ = Authentication עם Challenge-Response.

📡 DataPlex v2.0

Header (8B): Version(02) | Type | Seq(2B) | Ack(2B) | Window | Checksum(SUM%256)
Types: 10=SYN, 20=SYN-ACK, 30=DATA, 40=ACK, 50=NACK, 60=FIN
Handshake: SYN(Seq=X)→SYN-ACK(Seq=Y,Ack=X+1)→ACK(Seq=X+1,Ack=Y+1)
ACK number = next expected Seq. NACK = request retransmit.

// Handshake Analysis:
P1 SYN:     02 10 00 00 00 00 05 17  (Sum=0x17)
P2 SYN-ACK: 02 20 00 64 00 01 05 8C  (Seq=100,Ack=1)
P3 ACK:     02 40 00 01 00 65 05 AD  (Seq=1,Ack=101)
// NACK: server שלח על Seq=2 → Client retransmits DATA Seq=2

📡 SecureQ v3.0

Header (10B): Magic(51)|Type|ClientID|SessionID|PayLen|Flags|Seq(2B)|Checksum(2B,SUM%65536)
Auth: INIT→CHALLENGE(token)→RESPONSE(token XOR secret)→GRANTED/DENIED
DATA only after GRANTED. PayLen≤64. SessionID must match.

✏תרגול — DataPlex ו-SecureQ4 שאלות

תרגול 10.1

DataPlex: DATA(Seq=7) → ACK מהReceiver. מה Ack Number?

✓ 8 — Ack = next expected = Seq+1 = 8.

תרגול 10.2 — Window

DataPlex Window=1. מתי יכול לשלוח DATA נוסף?

✓ ג) — Window=1: רק 1 unacked. חייב ACK לפני שהולכים הלאה.

תרגול 10.3 — SecureQ

SecureQ DATA לפני GRANTED. מה קורה?

✓ ב) — R1: DATA only valid in GRANTED state. State Machine מנצח.

תרגול 10.4 — XOR Trick

XOR של [0x12, 0x12, 0x12, 0x12] = ?

✓ 0x00 — 12^12=0, 0^12=12, 12^12=0. זוגות שווים מבטלים!

🎯 דגש למבחן — אלימינציה מהירה בפרוטוקולים

לפני שמתחילים לחשב Checksum ארוך: בדקו קודם את ה־Magic Byte ואת אורך ה־Payload מול ההצהרה ב־Header. ברוב שאלות "מה שגוי?" הפסילה מגיעה כבר משם — וזה חוסך דקות יקרות. רק אם שניהם תקינים, גשו לחישוב ה־Checksum.

// אתגר מעשי

אתגר מעשי — פרוטוקול תקשורת: ביטים ומסגרות

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

T2 · בסיסי200 נק'~15 דק'algorithmic

רגיסטר ביט-פלאגים (Set/Clear/Toggle)

בפרוטוקולים רבים דגלים נשמרים כביטים ברגיסטר יחיד. נתון ערך התחלתי F ורשימת פעולות; כל פעולה היא "SET n" (הדלק את ביט n), "CLR n" (כבה את ביט n), "TOG n" (הפוך את ביט n). החזר את הערך הסופי של F.

דוגמאות

bit_ops(0, ['SET 0','SET 3']) → 9

bit_ops(0b1111, ['CLR 1']) → 13

bit_ops(0, ['TOG 2','TOG 2']) → 0

הפתרון שלךהפתרון נשמר מקומית ומשותף עם עמוד „כתיבת קוד”.

פתרון-ייחוס רגיסטר ביט-פלאגים (Set/Clear/Toggle) ›

def bit_ops(F: int, ops: list[str]) -> int:
    for o in ops:
        cmd, n = o.split(); n = int(n)
        if   cmd == 'SET': F |= (1 << n)       # הדלק ביט
        elif cmd == 'CLR': F &= ~(1 << n)      # כבה ביט
        elif cmd == 'TOG': F ^= (1 << n)       # הפוך ביט
    return F

T3 · בינוני400 נק'~30 דק'algorithmic

פרסור מסגרות פרוטוקול + Checksum

פענח זרם בייטים (רשימת מספרים 0–255) של פרוטוקול ממוסגר. כל מסגרת: בייט התחלה 0x7E, ואז LEN, ואז LEN בייטים של מטען (payload), ואז בייט checksum ששווה ל-XOR של כל בתי המטען. סרוק את הזרם: דלג על בייטים עד 0x7E; קרא מסגרת; אם ה-checksum תקין — אסוף את המטען, אחרת דלג עליה; המשך. עצור אם מסגרת נקטעת (אין מספיק בייטים). החזר את רשימת המטענים התקינים (כרשימות).

דוגמאות

parse_frames([0x7E,3,1,2,3,0]) → [[1, 2, 3]]

parse_frames([0x7E,2,1,9,0]) → [] # xor=8 ≠ 0

הפתרון שלךהפתרון נשמר מקומית ומשותף עם עמוד „כתיבת קוד”.

פתרון-ייחוס פרסור מסגרות פרוטוקול + Checksum ›

def _xor(payload):
    c = 0
    for b in payload: c ^= b
    return c
def parse_frames(stream: list[int]) -> list[list[int]]:
    out = []; i = 0; n = len(stream); START = 0x7E
    while i < n:
        if stream[i] != START: i += 1; continue      # סנכרון על START
        if i + 1 >= n: break
        ln = stream[i + 1]
        if i + 2 + ln + 1 > n: break                 # מסגרת קטומה
        payload = stream[i + 2 : i + 2 + ln]
        chk = stream[i + 2 + ln]
        if _xor(payload) == chk: out.append(payload)  # checksum תקין
        i = i + 2 + ln + 1                            # קדם מעבר לכל המסגרת
    return out

// סיכום

State Machine וסיכום

State Machine = מגדיר מצבים ומעברים חוקיים. השאלה הנפוצה: "מה שגוי ב-Sequence הזה?"

פרמטר	StreamLink	DataPlex	SecureQ
Header size	6 bytes	8 bytes	10 bytes
Checksum	XOR	SUM%256	SUM%65536
Max PayLen	128	ללא הגבלה	64
Reliability	Best-effort	Reliable (NACK)	Authenticated

✓מה למדנו — שיעור 13

5 שלבים לפרוטוקול: סקר → מיפוי → Checksum → Trace → ענה
XOR Checksum: XOR כל הbytes. SUM: סכום mod 256.
Flags: (F>>n)&1 לבדיקה. F|(1<<n) להדלקה.
State Machine: Invalid Transition = מעבר לא מוגדר במפרט
StreamLink XOR · DataPlex SUM+Handshake · SecureQ Auth+16-bit

🎯 שיעור הבא — שיעור 14

סימולציית כנס גאמא מלאה: שפה מומצאת + פרוטוקול מומצא בו-זמנית. 35 שאלות, 3 שעות. אסטרטגיית ניהול זמן.

✏תרגול סיכום — גאמא סטייל5 שאלות

סיכום 1

FUNC f(n)
    IF n=0 THEN RETURN 0 END IF
    IF n=1 THEN RETURN 1 END IF
    IF n MOD 2=0 THEN RETURN f(n/2) END IF
    RETURN f(n-1)+f(n-2)
END FUNC
PRINT f(7)

✓ 5 — f(7)=f(6)+f(5). f(6)=f(3)=2. f(5)=f(4)+f(3)=1+2=3. f(7)=5.

סיכום 2 — comparisons

כמה comparisons ב-Bubble Sort על n=5?

✓ 10 — n*(n-1)/2 = 5*4/2 = 10. Pass0: 4, Pass1: 3, Pass2: 2, Pass3: 1.

סיכום 3 — SUM Checksum

SUM Checksum: [0xAA, 0xBB, 0x03, 0x01] % 256 = ?

✓ 0x69 — 170+187+3+1=361. 361%256=105=0x69.

סיכום 4 — השוואה

מה ההבדל בין StreamLink ל-DataPlex מבחינת Reliability?

✓ א) — DataPlex: NACK+Retransmit = Reliable. StreamLink: Best-effort (אין NACK).

סיכום 5 — Checksum שגוי

מה הצעד הנכון כש-Checksum שגוי?

✓ א) — לא מתקנים נתונים פגומים — מבקשים שוב! DataPlex: NACK. StreamLink: ERROR.

שאלות תרגול ותשובות (10)

תרגול 13.1 · מה Magic byte? למה הוא קיים?

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

תשובה: ג

✓ תשובה: ג) — Magic = sentinel ידוע. מקבל בודק: Magic=0x5A? כן→ זה StreamLink. לא→ זרוק. מונע עיבוד של data רנדומי כ-Packet.

תרגול 13.2 · מה ההבדל בין Checksum שגוי ל-Packet לא חוקי (Invalid)?

א. אין ביניהם כל הבדל מעשי
ב. Invalid הוא צירוף של Checksum שגוי ושל Magic שגוי
ג. Checksum שגוי = נתונים שנפגמו בדרך; Invalid = מבנה שגוי לפי המפרט
ד. Checksum שגוי הוא בעצם אותו דבר כמו Invalid

תשובה: ג

✓ תשובה: ג) — Checksum שגוי = נתון תקין שנפגם בשידור. Invalid = הPacket עצמו בנוי לא לפי כללי המפרט. שתי שגיאות שונות!

תרגול 13.3 · DataPlex: SYN(Seq=10) → SYN-ACK(Seq=50,Ack=?). מה Ack?

Header (8B): Version(02) | Type | Seq(2B) | Ack(2B) | Window | Checksum(SUM%256)
Types: 10=SYN, 20=SYN-ACK, 30=DATA, 40=ACK, 50=NACK, 60=FIN
Handshake: SYN(Seq=X)→SYN-ACK(Seq=Y,Ack=X+1)→ACK(Seq=X+1,Ack=Y+1)
ACK number = next expected Seq. NACK = request retransmit.

א. 10
ב. 11
ג. 50
ד. 51

תשובה: ב

✓ תשובה: ב) 11 — Ack = Seq_received + 1 = 10+1 = 11. "קיבלתי Seq=10, מצפה לSeq=11."

תרגול 13.4 · חשב XOR Checksum: [0xFF, 0x00, 0xAA, 0x55]

א. 0xFF
ב. 0xAA
ג. 0x55
ד. 0x00

תשובה: ד

✓ תשובה: ד) 0x00 — FF XOR 00=FF, FF XOR AA=55, 55 XOR 55=00.

תרגול 13.5 · StreamLink Flags=0x06. מה דולק? (bit0=URGENT, bit1=ENCRYPTED, bit2=LAST)

א. URGENT בלבד
ב. URGENT ו-ENCRYPTED
ג. ENCRYPTED ו-LAST
ד. כל שלושת הדגלים דולקים יחד

תשובה: ג

✓ תשובה: ג) — 0x06=0110: bit0=0, bit1=1=ENCRYPTED, bit2=1=LAST.

תרגול 13.6 · Flags byte: URGENT דולק (bit0), LAST דולק (bit2), ENCRYPTED כבוי. מה הערך?

א. 0x05
ב. 0x03
ג. 0x07
ד. 0x06

תשובה: א

✓ תשובה: א) 0x05 — bit0=1, bit1=0, bit2=1 → 0b00000101 = 0x05.

תרגול 13.7 · SecureQ RESPONSE: token=0x2B, secret=0x7F. מה Payload?

א. 0x2B
ב. 0x54
ג. 0x7F
ד. 0xA9

תשובה: ב

✓ תשובה: ב) 0x54 — 0x2B XOR 0x7F: 0010 1011 XOR 0111 1111 = 0101 0100 = 0x54

תרגול 13.8 · StreamLink Header: 5A 01 03 00 00. מה Checksum?

א. 0x5E
ב. 0x5B
ג. 0x58
ד. 0x5C

תשובה: ג

✓ 0x58 — 5A^01=5B, ^03=58, ^00=58, ^00=58.

תרגול 13.9 · Sequence: HELLO → DATA → BYE → DATA. מה שגוי?

א. הרצף כולו תקין לחלוטין
ב. ה-DATA האחרון — אחרי BYE המכונה חזרה ל-IDLE
ג. ה-BYE הוא הצעד השגוי ברצף
ד. ה-HELLO הוא הצעד השגוי ברצף

תשובה: ב

✓ תשובה: ב) — BYE→IDLE. DATA ב-IDLE = Invalid Transition!

תרגול 13.10 · StreamLink Packet התקבל עם Magic=0x5B (במקום 0x5A). כמה שגיאות יתגלו בבדיקה?

Header (6B): Magic(5A) | Type(01-04,FF) | Seq | PayLen | Flags | Checksum
Flags: bit0=URGENT, bit1=ENCRYPTED, bit2=LAST, bits3-7=0
Checksum = XOR(bytes 0-4, all payload bytes)
Rules: PayLen≤128, Reserved flags=0, Magic=5A always
State: IDLE→(HELLO)→CONNECTED→(DATA)→CONNECTED→(BYE)→IDLE

א. 2 שגיאות
ב. 0 שגיאות והכול תקין
ג. שגיאה אחת של ה-Magic בלבד
ד. 3 שגיאות נפרדות בבת-אחת

תשובה: א

✓ תשובה: א) — Magic≠0x5A → validation fail. Magic חלק מחישוב XOR → Checksum שגוי גם.

← שיעור קודם שיעור הבא →