Network
מבחנים מסכמים
שאלות מכל נושאי רשתות, מעורבבות במבחנים מסכמים.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
מבחנים מסכמים: עשרים מושגי רשתות בחזרה אחת
הפרק הזה מרכז במקום אחד עשרים מושגי יסוד ברשתות, מהסוג שחוזר שוב ושוב בשאלות. הוא בנוי לחזרה מהירה, גם בימים האחרונים שלפני המבחנים.
- בקשות ושמות: השיטות POST ו-GET של HTTP, ומערכת השמות DNS.
- עבודה מרחוק ודואר: Telnet, SSH ו-IMAP.
- בתוך הרשת המקומית: Broadcast, ARP, DHCP, הפקודה ipconfig, וההתקנים Hub ו-Bridge.
- בגבול שבין הרשת לאינטרנט: NAT ו-DMZ.
- חיבורים ואבחון: Socket, הקריאות bind, listen ו-accept, לחיצת היד SYN/ACK, ICMP, TTL, Trace ו-Wireshark.
בדרך נפגוש גם כמה מושגים שכנים שאי אפשר להבין את העשרים בלעדיהם, כמו Switch, POP3 ו-SMTP.
כל מושג נבנה מהיסוד: מה הוא, איזו בעיה הוא בא לפתור, ואילו כללים מדויקים בודקות השאלות. כל חלק נסגר בטעויות שכדאי להכיר ובשאלות לבדיקה עצמית.
לקראת הסוף מחכה תרחיש אחד מקצה לקצה, מהרגע שמקלידים כתובת בדפדפן ועד שהעמוד מופיע, שמחבר את המושגים זה לזה.
POST ו-GET: שתי שיטות הבקשה של HTTP
בקשה, תשובה ושם השיטה
כשאתם גולשים, הדפדפן והשרת מנהלים שיחה בפרוטוקול HTTP: צד אחד שולח בקשה (Request), והצד השני מחזיר תשובה (Response). השורה הראשונה של כל בקשה נפתחת במילה אחת, השיטה (Method), שאומרת לשרת איזו פעולה מבקשים ממנו.
יש שיטות נוספות, למשל HEAD ו-DELETE, אבל בשאלות חוזרות שוב ושוב שתיים: GET ו-POST. כדי לראות איפה כל אחת מהן שמה את הנתונים, הנה שרת זעיר שמדפיס כל בקשה בדיוק כפי שהגיעה אליו, בית אחר בית:
import socket, threading, http.client, urllib.parse
listener = socket.socket()
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(("127.0.0.1", 8088))
listener.listen()
def show_raw_requests(count):
for _ in range(count):
conn, _ = listener.accept()
data = b""
while b"\r\n\r\n" not in data: # read until the blank line after the headers
data += conn.recv(4096)
head, _, body = data.partition(b"\r\n\r\n")
length = 0
for line in head.split(b"\r\n"):
if line.lower().startswith(b"content-length:"):
length = int(line.split(b":")[1])
while len(body) < length: # the body may arrive after the headers
body += conn.recv(4096)
print(head.decode())
print() # the blank line that ends the headers
if body:
print(body.decode())
print("-----")
conn.sendall(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\n\r\n")
conn.close()
t = threading.Thread(target=show_raw_requests, args=(2,))
t.start()
# GET: the filter values travel inside the URL
c = http.client.HTTPConnection("127.0.0.1", 8088)
c.putrequest("GET", "/catalog?color=red&size=42", skip_accept_encoding=True)
c.endheaders()
c.getresponse().read()
c.close()
# POST: the same kind of values travel in the body
body = urllib.parse.urlencode({"email": "noa@shop.test", "pin": "7319"}).encode()
c = http.client.HTTPConnection("127.0.0.1", 8088)
c.putrequest("POST", "/signin", skip_accept_encoding=True)
c.putheader("Content-Type", "application/x-www-form-urlencoded")
c.putheader("Content-Length", str(len(body)))
c.endheaders(body)
c.getresponse().read()
c.close()
t.join()GET /catalog?color=red&size=42 HTTP/1.1
Host: 127.0.0.1:8088
-----
POST /signin HTTP/1.1
Host: 127.0.0.1:8088
Content-Type: application/x-www-form-urlencoded
Content-Length: 30
email=noa%40shop.test&pin=7319
-----בבקשת ה-GET ערכי הסינון color=red&size=42 הם חלק מהנתיב עצמו, אחרי סימן השאלה. החלק הזה נקרא Query String.
בבקשת ה-POST הנתיב /signin נשאר נקי. הנתונים מופיעים רק אחרי השורה הריקה שסוגרת את הכותרות, כלומר בגוף הבקשה (Body).
Content-Length: 30 מודיעה לשרת כמה בתים של גוף עליו לקרוא. ה-@ שבכתובת המייל הפך ל-%40, כי כך מקודדים תווים מיוחדים בטופס. זה קידוד ולא הצפנה: כל אחד יכול להחזיר אותו לצורתו המקורית.GET מול POST, היבט אחר היבט
| היבט | GET | POST |
|---|---|---|
| למה היא נועדה | לקבל משאב: עמוד, קובץ, רשימת תוצאות | למסור נתונים לשרת: טופס, יצירה של רשומה או עדכון שלה |
| איפה הנתונים | ב-URL, אחרי ? | בגוף הבקשה, אחרי הכותרות |
| היסטוריית הדפדפן, סימניות ויומני השרת | הנתונים נרשמים בהם, כי הם חלק מהכתובת | נרשמת רק הכתובת, בלי מה שיש בגוף |
| קישור לשיתוף או סימנייה | עובד: פתיחת הקישור שולחת שוב את אותה בקשה | לא עובד: בכתובת לבדה אין את הנתונים |
| השפעה על השרת | אמורה רק לקרוא, ולכן מותר לחזור עליה בלי חשש | יכולה לשנות מצב, וחזרה עליה עלולה לבצע את הפעולה שוב (למשל לחייב פעמיים) |
| מטמון (Cache) | מתאימה לשמירה במטמון | בדרך כלל לא נשמרת במטמון |
| כמות נתונים | מוגבלת בפועל, כי דפדפנים ושרתים מגבילים את אורך ה-URL | לא כפופה למגבלת האורך של הכתובת, ולכן מתאימה לנפח גדול |
איך בוחרים? אם התוצאה היא משהו שרוצים לחזור אליו או לשלוח למישהו בקישור, כמו חיפוש, סינון מוצרים או עמוד מסוים, בוחרים GET. אם שולחים פרטים אישיים, נרשמים, מתחברים או מעלים טקסט ארוך, בוחרים POST.
את הטקסט הארוך כדאי לזכור במיוחד. כתובת URL ארוכה מדי עלולה להיקטע בדרך או להיענות בשגיאה, ואילו לגוף הבקשה אין את המגבלה הזאת.
חזרה לתוכן הענייניםהאם POST שומר על סודות?
לא. שום דבר ב-POST לא מצפין. אם האתר עובד ב-HTTP פשוט, גוף הבקשה עובר ברשת כטקסט קריא, בדיוק כמו ה-Query String של GET, וכל מי שלוכד את התעבורה (למשל ב-Wireshark) קורא את שניהם.
ההצפנה מגיעה מ-HTTPS, ו-HTTPS מגן על שתי השיטות באותה מידה. בפלט שלמעלה ה-PIN של המשתמשת מופיע בגוף הבקשה כמו שהוא.
אז למה בכל זאת שולחים סיסמאות ב-POST? כי הן לא נכנסות לכתובת, ולכן לא נשארות בהיסטוריה, בסימניות או ביומני הגישה של השרת. הבעיה בסיסמה שנשלחת ב-GET היא החשיפה הזאת, ולא חשש שהשרת לא יצליח לקרוא אותה או שהיא תיקטע.
תרחיש 1: קישור לתוצאות וטופס כניסה באותה חנות
רוני מסננת בחנות מקוונת נעליים אדומות במידה 42, שומרת את העמוד בסימנייה, ולמחרת הסימנייה מציגה בדיוק את אותה רשימה. מכאן אפשר להסיק שטופס הסינון נשלח ב-GET: הסינון כולו כתוב בכתובת שנשמרה.
לו הטופס היה נשלח ב-POST, הסימנייה הייתה שומרת רק את /catalog, והרשימה המסוננת לא הייתה חוזרת.
בעמוד הכניסה של אותה חנות הטופס נשלח ב-POST. אם החנות עדיין לא עברה ל-HTTPS, מי שמאזין לרשת ה-Wi-Fi של בית הקפה יקרא את הסיסמה מתוך גוף הבקשה.
מה כן הרווחנו? הסיסמה לא תופיע בהיסטוריה של המחשב ולא תישמר באף סימנייה.
טעויות נפוצות
- בקשת POST מוצפנת, ולכן היא בטוחה גם בלי HTTPS. POST רק קובע איפה הנתונים יושבים. בלי HTTPS גוף הבקשה קריא לכל מי שמאזין.
- הפרמטרים שאחרי
?מוצפנים, ולכן לא נשמרים בשום מקום. אין שם הצפנה, והם נשמרים בהיסטוריה, בסימניות וביומני השרת. - לנפח גדול עדיף GET, כי לכתובת אין גבול אורך. ההפך: דווקא לאורך ה-URL יש גבול מעשי, ולכן נתונים גדולים שולחים ב-POST.
- תשובה לבקשת POST נשמרת במטמון, ותשובה ל-GET לא. זה הפוך. GET היא השיטה שמתאימה למטמון.
- ב-GET הנתונים עוברים בגוף הבקשה. בגוף הבקשה יושבים הנתונים של POST. ב-GET הם בכתובת.
בדקו את עצמכם
אתר להזמנת כרטיסים עובד ב-HTTP בלבד, ופרטי ההזמנה נשלחים ב-POST. מי שלוכד תעבורה באותה רשת, יראה את הפרטים?
כן. POST לא מצפין, וגוף הבקשה עובר כטקסט רגיל. רק HTTPS היה מסתיר אותו.
מפתחת רוצה שמשתמשים יוכלו לשלוח זה לזה קישור לדוח מסונן לפי תאריכים. באיזו שיטה כדאי לשלוח את טופס הסינון?
GET. כך התאריכים נכתבים בכתובת עצמה, והקישור לבדו מספיק כדי להפיק שוב את אותו דוח.
למה בבקשת ה-POST שבדוגמה ה-PIN לא יופיע בהיסטוריית הדפדפן?
כי הוא נמצא בגוף הבקשה, וההיסטוריה שומרת רק את הכתובת /signin.
DNS: ספר הכתובות של הרשת
מה DNS עושה, ועל איזה פורט
תוכנות מתקשרות זו עם זו לפי כתובות IP, ואנשים מעדיפים לזכור שמות. DNS (Domain Name System) הוא השירות שמקבל שם מתחם, כמו docs.example.org, ומחזיר לכם כתובת IP.
חשוב לא פחות לדעת מה הוא לא עושה: הוא לא מעביר הודעות דואר, לא שומר עותקים של עמודי אינטרנט, לא בולם התקפות DDoS ולא מחלק כתובות למחשבים. התפקיד שלו הוא תרגום של שמות, וזהו.
DNS עובד על פורט 53, ושאילתה רגילה יוצאת ב-UDP. TCP נכנס לתמונה בשני מקרים: כשהתשובה לא נכנסת בחבילת UDP, השרת מסמן שהיא נקטעה והלקוח שואל שוב ב-TCP; וכשמעתיקים אזור (Zone) שלם משרת אחד לאחר.
חזרה לתוכן הענייניםסוגי הרשומות שצריך להכיר
| רשומה | על איזו שאלה היא עונה |
|---|---|
| A | איזו כתובת IPv4 שייכת לשם |
| AAAA | איזו כתובת IPv6 שייכת לשם |
| CNAME | השם הזה הוא כינוי, והשם האמיתי הוא שם מתחם אחר (לא כתובת) |
| MX | איזה שרת דואר מקבל את ההודעות שנשלחות לדומיין |
| NS | איזה שרת DNS אחראי על הדומיין |
| PTR | הכיוון ההפוך: איזה שם שייך לכתובת IP מסוימת |
נניח ש-shop.example.org מוגדר כ-CNAME של stores.example.org. מי ששואל על shop מופנה אל stores, והכתובת נלקחת מרשומת ה-A של stores. לכן מספיק לעדכן כתובת במקום אחד, וכל הכינויים שמפנים לשם הזה עוברים לערך החדש בלי שנוגעים בהם.
ההחלפה אינה מיידית: מי ששמר במטמון תשובה ישנה ימשיך להשתמש בה עד שה-TTL שלה יפוג.
מכאן גם שתי טעויות שכדאי לפסול: CNAME לא מכיל כתובת IP, והוא לא מעתיק אותה ברגע ההגדרה. ועוד כלל אחד: לשם שהוגדר לו CNAME אסור להוסיף רשומות אחרות, למשל MX.
רשומת MX מחזירה שם של שרת ולא כתובת. כדי למסור הודעה ל-dana@example.org, השרת השולח מבקש קודם את רשומת ה-MX של example.org ומקבל, למשל, mx1.example.org. רק אחר כך הוא מבקש את רשומת ה-A של mx1, כדי לדעת לאיזו כתובת להתחבר.
מי שואל את מי: Resolver ושרשרת השרתים
במחשב שלכם פועל רכיב שנקרא Resolver. התפקיד שלו הוא לפנות לשרתי ה-DNS ולהביא את הכתובת שמתאימה לשם. הוא לא מנהל טבלת MAC, לא מסנן אתרים ולא עוקב אחרי שרתי DHCP.
המחשב לא מטייל בעצמו בין השרתים. הוא מעביר את השאלה לשרת ה-DNS שהוגדר לו, והשרת הזה, שנקרא Recursive Resolver, עושה בשבילו את כל הדרך:
- שרת Root, שמפנה הלאה לשרתים של הסיומת.
- שרת TLD של הסיומת (למשל
.org), שמפנה לשרת של הדומיין עצמו. - השרת הסמכותי (Authoritative) של הדומיין, שבידיו התשובה.
את כל הסיבוב הזה עושים רק כשהתשובה לא שמורה כבר במטמון. כדי לשאול שרת DNS בעצמכם יש שני כלים מוכרים, nslookup ו-dig:
nslookup docs.example.org
dig docs.example.org AAAA
dig example.org NSהבדל שמופיע בשאלות: לפני שמערכת ההפעלה פונה ל-DNS היא מסתכלת בקובץ hosts, ולכן שורה בקובץ הזה משפיעה על ping ועל הדפדפן. לעומת זאת nslookup ו-dig שואלים את שרת ה-DNS ישירות, ולא מסתכלים ב-hosts בכלל.
מטמון, TTL ומה קורה אחרי שינוי כתובת
אם כל גלישה הייתה מחייבת לעבור את כל השרשרת מחדש, שרתי ה-DNS היו כורעים תחת העומס. לכן גם הלקוח וגם ה-Resolver שומרים תשובות במטמון (Cache), וכך יורד העומס מהשרתים וזמן התגובה מתקצר.
כמה זמן מותר לשמור? כל רשומה מגיעה עם TTL, מספר שניות שבעל הדומיין קבע. ככל שהמספר גדול יותר, הרשומה נשארת במטמון זמן רב יותר לפני שפונים שוב לשרת.
כשהזמן נגמר הרשומה פגה, והשאלה הבאה תגיע שוב לשרת. אין רשומה שנשמרת לתמיד.
הסימולציה הבאה מראה מה רואה לקוח כשבעל האתר מחליף כתובת בזמן שהרשומה הישנה עדיין במטמון שלו:
# A client-side DNS cache, with a clock that we move by hand
cache = {} # name -> (address, expires_at)
server = {"lab.example.net": "192.0.2.10"}
TTL = 1800 # seconds, set by the domain owner
def resolve(name, now):
if name in cache and now < cache[name][1]:
print(f"t={now:>4}: {cache[name][0]} (from cache)")
return
address = server[name] # ask the DNS server again
cache[name] = (address, now + TTL)
print(f"t={now:>4}: {address} (asked the server, kept until t={now + TTL})")
resolve("lab.example.net", 0)
server["lab.example.net"] = "192.0.2.99" # the owner moves the site at t=600
resolve("lab.example.net", 600)
resolve("lab.example.net", 1799)
resolve("lab.example.net", 1800)t= 0: 192.0.2.10 (asked the server, kept until t=1800)
t= 600: 192.0.2.10 (from cache)
t=1799: 192.0.2.10 (from cache)
t=1800: 192.0.2.99 (asked the server, kept until t=3600)השינוי בשרת קרה בשנייה 600, אבל הלקוח המשיך לקבל את הכתובת הישנה עד שה-TTL שלה נגמר בשנייה 1800. הרגע שקובע הוא פקיעת ה-TTL, ולא 'כשהמחשב יופעל מחדש'.
מכאן הפשרה. TTL קצר מאוד מכריח את הלקוחות לשאול שוב ושוב, ולכן מעמיס על שרתי ה-DNS, אבל כל שינוי מגיע אליהם מהר. TTL ארוך חוסך שאילתות, אבל שינוי לוקח זמן רב עד שכולם רואים אותו.
ב-Windows אפשר לרוקן את המטמון המקומי בפקודה ipconfig /flushdns, וכך השאילתה הבאה יוצאת שוב לשרת.
DNS פנימי, שרת גיבוי והרעלת מטמון
- שרת DNS פנימי: ארגון מריץ שרת משלו כדי לתרגם שמות של מערכות פנימיות, כמו
wiki.corp.local, שאין להן רשומות ב-DNS הציבורי. השרת הזה לא מחלק כתובות (זו עבודה של DHCP), והוא גם לא חושף את השמות הפנימיים לגולשים מהאינטרנט. - שני שרתי DNS ללקוח: המטרה היא גיבוי. אם הראשון לא עונה, הלקוח פונה לשני וממשיך לפתור שמות. אין ביניהם חלוקת תפקידים, והלקוח לא שולח כל שאלה לשניהם יחד.
- DNS cache poisoning: תוקף מצליח להכניס למטמון של שרת רשומה מזויפת. כל לקוח שמקבל ממנו את הרשומה מקבל כתובת IP שגויה ומגיע לאתר שבשליטת התוקף.
תרחיש 2: האתר עבר שרת, וחלק מהעובדים עדיין מגיעים לישן
בשעה 09:00 מנהל המערכת משנה את רשומת ה-A של portal.example.org כך שתצביע על השרת החדש. ה-TTL של הרשומה הישנה היה 7200 שניות, כלומר שעתיים.
עובד שהמחשב שלו שאל על השם בשעה 08:30 מחזיק את הכתובת הישנה עד 10:30, ולכן ימשיך להגיע לשרת הישן עוד כשעה וחצי.
אם העובד מריץ ipconfig /flushdns, המחשב שלו ישאל מחדש. אבל השאלה מגיעה ל-Resolver של הארגון, ואם גם שם הרשומה הישנה עוד שמורה, הוא יחזיר אותה עד שה-TTL שלו יפוג.
הלקח: מי שמתכנן העברה מקצר את ה-TTL זמן מה מראש. המחיר הוא יותר שאילתות לשרתי ה-DNS בתקופת המעבר.
טעויות נפוצות
- רשומת AAAA (או PTR) נותנת את כתובת ה-IPv4 של שם. לכתובת IPv4 יש רשומת A. AAAA מיועדת ל-IPv6, ו-PTR עובדת בכיוון ההפוך, מכתובת לשם.
- DNS הוא שמתרגם כתובת IP לכתובת MAC. זה ARP. DNS מתרגם שמות לכתובות IP.
- ה-TTL של רשומת DNS סופר כמה נתבים השאילתה עוברת. את זה עושה ה-TTL של כותרת IP. ברשומת DNS זה מספר השניות שמותר לשמור אותה.
- CNAME שומר עותק של הכתובת ששייכת לשם שהוא מפנה אליו. CNAME מכיל רק שם אחר. הכתובת נלקחת בכל פעם מרשומת ה-A של השם ההוא.
- רשומת MX נותנת כתובת IP שמובילה ישר לתיבת הדואר של המשתמש. היא מחזירה שם של שרת דואר לדומיין כולו. את הכתובת שלו מקבלים בשאילתה נוספת.
- רשומה עם TTL של 0 נשארת במטמון ללא הגבלה. TTL של 0 אומר שלא שומרים אותה בכלל, וכל שאלה מגיעה שוב לשרת.
בדקו את עצמכם
במחשב Windows, ping intra.example.org פונה לכתובת אחת, ו-nslookup intra.example.org מחזיר כתובת אחרת ועדכנית. מה ההסבר הסביר?
ping עובר דרך מערכת ההפעלה, שבודקת קודם את קובץ hosts ואת המטמון המקומי, ואילו nslookup שואל את שרת ה-DNS ישירות. כנראה שבמחשב נשארה כתובת ישנה במטמון או שורה ב-hosts.
שרת דואר צריך למסור הודעה לדומיין example.org. איזו רשומה הוא מבקש קודם, ומה הוא עושה עם התשובה?
רשומת MX. היא מחזירה שם של שרת דואר, ואז הוא מבקש את רשומת הכתובת של השם הזה כדי לדעת לאן להתחבר.
למה מקצרים TTL לפני מעבר שרת, ולא משאירים אותו קצר תמיד?
TTL קצר גורם לשינוי להגיע ללקוחות מהר, אבל כל עוד הוא קצר הלקוחות שואלים יותר, והעומס על שרתי ה-DNS עולה.
Telnet ו-SSH: מסוף על מחשב אחר
Telnet: מסוף מרוחק בלי שום הגנה
Telnet פותח לכם חלון טקסט (Terminal) על מחשב אחר: אתם מקלידים אצלכם, והפקודות מתבצעות במכונה המרוחקת. הוא רץ על TCP, בפורט 23.
הבעיה היא שהכול עובר כמו שהוא, בלי הצפנה: שם המשתמש, הסיסמה וכל פקודה ופקודה. מי שלוכד את התעבורה, למשל ב-Wireshark, קורא את כל ההתחברות.
לכן לא מפעילים Telnet ברשת ציבורית, ובארגון עדיף לוותר עליו. אם בכל זאת אין ברירה, מגבילים אותו לרשת הפנימית בלבד.
כדאי לזכור מה לא עוזר: העברה לפורט אחר, סיסמה ארוכה ומסובכת או הפעלה רק מבפנים לא הופכות את התעבורה למוצפנת. ל-Telnet אין TLS מובנה, ואין לו קשר לפורט 443.
חזרה לתוכן הענייניםTelnet ככלי לבדיקת פורט
נשאר ל-Telnet שימוש אחד שעדיין מועיל: לברר אם שרת מרוחק מקבל חיבורי TCP בפורט מסוים. כותבים כתובת ופורט:
telnet 172.16.4.20 3389
telnet files.example.org 21Telnet פשוט מנסה לפתוח חיבור TCP אל היעד שציינתם, וזה כל המבחן. אם החיבור קם, בצד השני יש תוכנה שמאזינה בפורט. אם הוא נדחה, אין שם מאזין, ואם אין תשובה בכלל, סביר שחומת אש בולעת את הניסיון.
אותו מבחן בדיוק, כתוב ב-Python, על שני פורטים במחשב שלכם: באחד מאזין שירות קטן, ובשני אין אף אחד. הזמן הקצוב הוא 5 שניות, כי ב-Windows דחייה של פורט סגור במחשב המקומי מגיעה רק אחרי כשתי שניות, וזמן קצר מזה היה מציג בטעות 'חסום':
import socket
# a tiny service that listens on port 2525 of this machine
service = socket.socket()
service.bind(("127.0.0.1", 2525))
service.listen()
def tcp_probe(port):
# the same test telnet makes: try to open a TCP connection, nothing more
s = socket.socket()
s.settimeout(5) # Windows refuses a closed local port only after about 2 s
try:
s.connect(("127.0.0.1", port))
print(port, "open: a program is listening")
except ConnectionRefusedError:
print(port, "refused: nothing listens there")
except socket.timeout:
print(port, "no answer: probably filtered by a firewall")
finally:
s.close()
tcp_probe(2525)
tcp_probe(2526)2525 open: a program is listening
2526 refused: nothing listens thereמה הבדיקה הזאת לא עושה: היא לא בודקת UDP, כי ב-UDP אין חיבור שאפשר להקים, והיא לא סורקת טווח של פורטים, אלא בודקת פורט אחד בכל הפעלה. וב-Windows לקוח ה-Telnet הוא רכיב אופציונלי שלא מותקן מראש, וצריך להוסיף אותו.
חזרה לתוכן הענייניםSSH: אותו רעיון, מוצפן
SSH (Secure Shell) נותן את אותו מסוף מרוחק, אבל כל התעבורה בין הצדדים מוצפנת. הוא רץ על TCP בפורט 22. שימו לב לשכנים שמופיעים כמסיחים: 21 שייך ל-FTP, 23 ל-Telnet ו-80 ל-HTTP.
מה שמבדיל באמת בין SSH ל-Telnet הוא ההצפנה, ולא מהירות, דחיסה או מספר פורט. ההגנה של SSH גם לא נובעת מכך שתוקפים 'לא יודעים' על איזה פורט הוא מאזין, והוא לא מאמת משתמשים על סמך הכתובת שממנה הם מגיעים.
מעבר למסוף, SSH משמש גם להעברת קבצים (scp ו-sftp) ולפתיחת מנהרות, שנגיע אליהן בהמשך.
שתי בדיקות זהות: המשתמש והשרת
בכל התחברות SSH מתבצעות שתי בדיקות שונות. אחת מוודאת שאתם מי שאתם טוענים, והשנייה מוודאת שהשרת הוא אותו שרת שהכרתם. ערבוב בין השתיים הוא מקור לטעויות רבות.
| מה מוכח | איך | איפה זה שמור |
|---|---|---|
| זהות המשתמש מול השרת | סיסמה, או זוג מפתחות: המשתמש מוכיח שהמפתח הפרטי נמצא בידיו | המפתח הפרטי אצל המשתמש, והמפתח הציבורי בשרת, בקובץ authorized_keys |
| זהות השרת מול הלקוח | השרת מציג את ה-host key שלו | הלקוח רושם אותו בקובץ known_hosts בהתחברות הראשונה ומשווה אליו בכל התחברות |
- אימות במפתחות חוסך את הקלדת הסיסמה וגם מחזק את האבטחה, כי אין סיסמה שאפשר לנחש.
- המפתח הפרטי לא יוצא מהמחשב שלכם. הוא לא נשלח לשרת ולא נשמר בו, וגם לא משמש להצפנת התעבורה: הוא רק מוכיח זהות, וההצפנה של הערוץ נקבעת בנפרד.
- הכיוון קבוע: הציבורי בשרת, הפרטי אצל המשתמש, ולא להפך.
- קובץ המפתח הפרטי שווה גישה. השרתים לא בודקים מי מחזיק בו, אלא רק שהוא מתאים לחצי הציבורי שהותקן אצלם. אם הקובץ דולף, הזר נכנס בשמכם לכל מקום כזה, ולכן שומרים עליו היטב ובדרך כלל נועלים אותו ב-passphrase.
- ssh-agent הוא תהליך שמחזיק בזיכרון את המפתחות הפרטיים אחרי שפתחתם אותם פעם אחת, כך שלא תצטרכו להקליד passphrase בכל התחברות לכל שרת. הוא לא מייצר מפתח חדש בכל חיבור, ולא כותב את המפתח לקובץ גלוי בדיסק.
ומה אם הלקוח מתריע REMOTE HOST IDENTIFICATION HAS CHANGED ולא מוכן להמשיך? המשמעות היא שהמפתח שהשרת הציג עכשיו לא תואם את מה שרשום ב-known_hosts.
יש לזה שני הסברים אפשריים: מישהו באמצע מתחזה לשרת (Man-in-the-Middle), או שהשרת הותקן מחדש וקיבל מפתח חדש. האזהרה לא אומרת דבר על הסיסמה שלכם, על המפתח הפרטי שלכם, על הכתובת שממנה התחברתם או על חסימה של פורט 22.
תרחיש 3: אזהרה על host key בבוקר רגיל
אורי, מפתח באחד הצוותים, מתחבר כל בוקר ב-SSH לשרת הבנייה build01. הבוקר הלקוח עוצר אותו עם אזהרה שהמפתח של השרת השתנה.
הוא בודק עם צוות התשתיות. אם השרת הותקן מחדש בלילה, השינוי לגיטימי, ומעדכנים את הרשומה ב-known_hosts.
אם איש לא נגע בשרת, ייתכן שמישהו בדרך מתחזה אליו, ואסור להקליד שם סיסמה עד שמבררים. בכל מקרה האזהרה עוסקת בזהות השרת, ולא במפתח הפרטי או בסיסמה של אורי.
מנהרות: Port Forwarding
SSH יכול להפוך פורט במחשב שלכם לפתח של מנהרה מוצפנת. כל חיבור שנכנס לפורט המקומי עובר בתוך חיבור ה-SSH ויוצא בצד השני אל שירות שבחרתם:
ssh -L 5433:db.internal:5432 maya@jump.example.orgכאן כל תוכנה שמתחברת ל-localhost:5433 מגיעה בפועל לפורט 5432 של db.internal, דרך השרת jump.example.org.
רק מה שפונה לפורט 5433 נכנס למנהרה. כל השאר ממשיך בדרך הרגילה, כולל שאילתות ה-DNS של התחנה, שיוצאות כרגיל לשרת ה-DNS שמוגדר בה ולא עוברות בתוך המנהרה.
אפשר גם להעביר Telnet בתוך מנהרת SSH, וכך הסיסמה עוברת בערוץ מוצפן. אבל ההצפנה מכסה רק את הדרך עד שרת ה-SSH: אם שרת ה-Telnet הוא מחשב אחר, הקטע שבין שרת ה-SSH אליו עובר גלוי.
טעויות נפוצות
- Telnet מצפין לפחות את הסיסמה, או משתמש ב-TLS. ב-Telnet שום דבר לא מוצפן, לא הסיסמה ולא שאר התעבורה, ואין לו TLS מובנה.
- ב-SSH יש הצפנה, אז מפתחות הם תוספת מיותרת. מפתחות הם שיטת אימות, לא תחליף להצפנה. החיבור מוצפן גם כשמתחברים בסיסמה, והמפתחות באים במקום הסיסמה.
- בהתחברות במפתחות, המפתח הפרטי נשלח לשרת ונשמר שם. הפרטי לא עוזב את המחשב של המשתמש. בשרת מותקן הציבורי.
- אפשר לבדוק ב-telnet אם שירות UDP מאזין. telnet מקים חיבור TCP בלבד, ולכן לא מלמד דבר על פורטים של UDP.
- telnet מגלה את הנתבים שבדרך או מתרגם שם לכתובת. את הנתבים מראה traceroute, ותרגום שמות עושים עם nslookup.
בדקו את עצמכם
telnet mail.example.org 587 פותח חלון ומקבל שורת פתיחה מהשרת, ו-telnet mail.example.org 588 נכשל. מה למדתם?
בפורט 587 מאזין שירות. פורט 588 לא נגיש: אין בו מאזין, או שחומת אש חוסמת אותו.
מישהו העתיק את הקובץ עם המפתח הציבורי שלכם. האם הוא יכול להתחבר לשרתים בשמכם?
לא. המפתח הציבורי אינו סוד, ובלי המפתח הפרטי אי אפשר להוכיח את הזהות.
פתחתם ssh -L על פורט מקומי 8443. האם גם הגלישה הרגילה בדפדפן עוברת עכשיו מוצפנת דרך השרת?
לא. רק חיבורים לפורט המקומי 8443 נכנסים למנהרה. כל שאר התעבורה, כולל DNS, יוצאת כרגיל.
IMAP: הדואר נשאר על השרת
שלושה פרוטוקולים של דואר, ומה כל אחד עושה
בדואר האלקטרוני יש חלוקת עבודה ברורה: פרוטוקול אחד שולח, ושניים משמשים לקבלה, כל אחד בדרך אחרת.
| פרוטוקול | תפקיד | פורטים |
|---|---|---|
| IMAP | גישה לתיבת דואר שנשמרת על השרת | 143, ו-993 עם TLS |
| POP3 | קבלת דואר, ובדרך כלל הורדה למכשיר ומחיקה מהשרת | 110, ו-995 עם TLS |
| SMTP | שליחת דואר | 25 או 587 |
IMAP לא שולח הודעות, ואין לו קשר להעברת קבצים בסגנון FTP. לכן כשמגדירים חשבון באפליקציית דואר, בשדה 'שרת נכנס' רושמים IMAP, ובשדה 'שרת יוצא' רושמים SMTP. קבלה וקריאה ב-IMAP, שליחה ב-SMTP.
גם POP3 הוא פרוטוקול קבלה ולא שליחה. DNS ו-SSH לא שולחים דואר בכלל: DNS רק עוזר לשרת השולח לאתר את שרת הדואר של הנמען, דרך רשומת MX.
חזרה לתוכן הענייניםמה מקבלים מ-IMAP
- ההודעות והתיקיות יושבות על השרת. הלקוח ניגש אליהן מרחוק ומתעדכן כשמשהו משתנה.
- השרת שומר גם את המצב של כל הודעה (נקראה או לא) ואת התיקייה שבה היא נמצאת, ולכן כל מכשיר שמתחבר רואה את אותה תמונה.
- זו הסיבה ש-IMAP מתאים למי שקורא דואר מכמה מכשירים. ב-POP3 ההודעות בדרך כלל יורדות למכשיר אחד ונמחקות מהשרת, ושאר המכשירים לא יראו אותן.
- IMAP IDLE: הקשר בין הלקוח לשרת לא נסגר, וכל הודעה חדשה נדחפת ללקוח באותו רגע. אין צורך לשאול את השרת שוב ושוב אם יש משהו חדש (Polling).
תרחיש 4: טאבלט ומחשב נייד על אותה תיבה
מיכל מחוברת לתיבה שלה ב-IMAP גם מהטאבלט וגם מהמחשב הנייד. בבוקר, בטאבלט, היא פותחת הודעה מרואה החשבון ומעבירה אותה לתיקייה 'מסים'.
בצהריים היא פותחת את המחשב הנייד, וההודעה כבר מסומנת כנקראה ונמצאת בתיקייה 'מסים'. שני הפרטים, המצב והמיקום, נשמרו בשרת, והמחשב רק סנכרן אותם.
אילו הטאבלט היה מוגדר ב-POP3, ההודעה הייתה יורדת אליו ונמחקת מהשרת, ובמחשב הנייד היא לא הייתה מופיעה בכלל.
כשמיכל עונה לרואה החשבון, התשובה יוצאת דרך שרת ה-SMTP. ל-IMAP אין חלק בשליחה.
טעויות נפוצות
- IMAP מוריד את ההודעות ומוחק אותן מהשרת. זו ההתנהגות הרגילה של POP3. ב-IMAP ההודעות נשארות על השרת.
- IMAP הוא הפרוטוקול ששולח את הדואר. שליחה היא SMTP. IMAP משמש לקריאה ולניהול התיבה.
- IMAP מסנכרן את התיקייה של ההודעה, אבל לא את הסימון שהיא נקראה. שני הדברים נשמרים בשרת ומסונכרנים.
- IMAP צריך חיבור קווי מהיר, ו-POP3 נועד לרשת סלולרית. לסוג החיבור אין קשר לעניין. ההבדל הוא היכן נשמרות ההודעות.
- ב-IMAP IDLE החיבור נסגר בין התראה להתראה כדי לחסוך. ההפך: החיבור נשאר פתוח, וזה מה שמאפשר לשרת להודיע מיד.
בדקו את עצמכם
אפליקציית דואר מותקנת בבית ובעבודה, ושתיהן מחוברות לאותה תיבה ב-IMAP. בבית מחקתם הודעה. מה יקרה בעבודה?
גם שם ההודעה תיעלם אחרי הסנכרון, כי שתי ההתקנות מציגות את אותה תיבה שנמצאת על השרת.
באפליקציה מוגדר שרת נכנס ב-IMAP, ומשתמש שואל אם אפשר להגדיר POP3 בתור השרת היוצא. מה תענו?
לא. POP3 הוא פרוטוקול קבלה. השרת היוצא הוא SMTP.
ברשת המקומית: Broadcast, ARP, DHCP ו-ipconfig
Broadcast: הודעה אחת לכל השכנים
ברשת מקומית יש שלושה דפוסי משלוח, וכדאי להכיר את שלושתם כי הם מופיעים זה לצד זה כמסיחים:
- Unicast: נמען אחד, שכתובתו כתובה בכותרת.
- Multicast: קבוצת נמענים שהצטרפו מראש לקבוצה.
- Broadcast (שידור): כל התחנות שבאותה תת-רשת (Subnet) מקבלות את אותה הודעה, שנשלחה פעם אחת.
בשכבת Ethernet יעד השידור הוא FF:FF:FF:FF:FF:FF. בשכבת IP יש לשידור שתי צורות:
| צורה | דוגמה | לאן היא מגיעה |
|---|---|---|
| Limited Broadcast | 255.255.255.255 | לרשת המקומית של השולח, גם כשהוא לא יודע מה כתובת הרשת |
| Broadcast לרשת מסוימת | 10.20.30.255 ברשת 10.20.30.0/24 | לכל התחנות של הרשת הזאת בדיוק |
נתבים לא מעבירים שידורים כברירת מחדל, ולכן תחום השידור נעצר בנתב. מחשב ברשת 10.20.30.0/24 ששולח ל-10.20.30.255 מגיע רק לשכנים שלו, ולא לרשת 10.20.31.0 שמעבר לנתב, ובטח שלא לאינטרנט.
התקני שכבה 1 ו-2 נוהגים אחרת: Hub, Bridge ו-Switch מעבירים שידור לכל הפורטים. הקבוצה של כל ההתקנים ששומעים שידור של אחד מהם, בלי נתב באמצע, נקראת Broadcast Domain.
שני שידורים שתפגשו כל הזמן הם ARP Request ו-DHCP Discover. שידור הוא כלי שימושי, אבל יש לו מחיר: כל תחנה בתחום חייבת לקבל אותו ולעבד אותו.
כשתחום שידור אחד גדל יותר מדי, ההודעות האלה מעמיסות על הרשת ומאטות אותה, ובמקרה קיצוני מציפות אותה עד שהיא משותקת.
Broadcast Storm הוא מצב שבו חבילות שידור מסתובבות ומשתכפלות בלי סוף, ובדרך כלל הגורם הוא לולאה בין מתגים. הלולאה לא נשברת מעצמה, כי למסגרת Ethernet אין שדה TTL שיסיים את חייה.
אל תבלבלו את זה עם ARP Spoofing (הודעות ARP מזויפות), עם הצפה של טבלת ה-MAC במתג או עם מיצוי מאגר הכתובות של DHCP.
חזרה לתוכן הענייניםARP: מכתובת IP לכתובת MAC
כדי להוציא מסגרת ברשת המקומית צריך לכתוב בה לאיזה MAC היא מיועדת, אבל מה שבדרך כלל ידוע הוא כתובת ה-IP. ARP (Address Resolution Protocol) סוגר את הפער: הוא מוצא איזו כתובת MAC שייכת לכתובת IP ברשת המקומית.
הכיוון ההפוך, מ-MAC ל-IP, היה התפקיד של RARP, פרוטוקול ישן שתחנות בלי דיסק השתמשו בו כדי לברר מה ה-IP שלהן, והיום הוא כבר לא בשימוש. ARP גם לא ממיר כתובת ל-URL, לא בודק אם מחשב זמין (זה ICMP) ולא חוסם תחנות.
כך זה נראה כשמחשב 10.20.30.5 רוצה לשלוח ל-10.20.30.40 שבאותה רשת, ואין לו את ה-MAC שלו:
- המחשב משדר לכל הרשת ARP Request: 'למי שייכת
10.20.30.40?' - רק בעל הכתובת עונה, ב-ARP Reply שנשלח ישירות (Unicast) לשואל, עם כתובת ה-MAC שלו.
- השואל רושם את התשובה בטבלת ה-ARP שלו ושולח את המסגרת.
את הטבלה שנבנית כך מציגים בפקודה arp -a, שמראה אילו כתובות MAC נלמדו עבור כתובות IP ברשת המקומית:
arp -aשימו לב מה היא לא מראה: טבלת ניתוב רואים ב-netstat -r או ב-route print, את מטמון ה-DNS ב-ipconfig /displaydns, ואת כרטיסי הרשת של המחשב עצמו ב-getmac. רשומה בטבלת ה-ARP יכולה להיות דינמית, כזו שפגה אחרי זמן מה, או סטטית.
- רק ברשת המקומית. כשהיעד ברשת אחרת, המחשב לא שואל על היעד אלא על ה-MAC של שער ברירת המחדל (הנתב), ושולח אליו. ה-Request הוא שידור, ונתב לא מעביר שידורים, ולכן ARP לא חוצה נתבים.
- בלי IP בכלל. את ARP עוטפים ישר במסגרת Ethernet, ואין חבילת IP באמצע. להודעת ARP אין כותרת IP, ולכן גם אין להודעה הזאת TTL.
- Gratuitous ARP: תחנה מודיעה מיוזמתה איזו כתובת MAC שייכת לכתובת ה-IP שלה. ההודעה מרעננת את הרשומות אצל השכנים, ולא היא שגורמת לרשומות מיושנות.
- רשומה מיושנת (Stale): אם כרטיס הרשת של היעד הוחלף, ה-MAC שלו השתנה. כל עוד הרשומה הישנה לא פגה ולא עודכנה, השולח ממשיך לכתוב במסגרות את ה-MAC הקודם.
- אין אימות. כל אחד יכול לשלוח ARP Reply, ומכאן ההתקפה ARP Spoofing (שנקראת גם ARP Poisoning).
ב-ARP Spoofing התוקף שולח הודעות ARP מזויפות שקושרות כתובת IP לגיטימית, בדרך כלל של הנתב, לכתובת ה-MAC שלו עצמו. מעכשיו התעבורה של הקורבנות עוברת דרכו, והוא יכול לקרוא אותה או לשבש אותה (Man-in-the-Middle).
שינוי של טבלת ה-ARP במחשב של התוקף בלבד לא עושה דבר לאחרים. ההתקפה עובדת רק כשהזיוף נכנס לטבלאות של הקורבנות.
חזרה לתוכן הענייניםDHCP: הגדרות רשת בלי הקלדה
DHCP (Dynamic Host Configuration Protocol) נותן לכל מכשיר שמצטרף לרשת את מה שהוא צריך כדי לעבוד: כתובת IP ומסכה, שער ברירת מחדל, שרתי DNS ומשך חכירה (Lease). בלעדיו הייתם צריכים להגדיר את כל זה ידנית בכל מכשיר.
ומה הוא לא עושה: לא מתרגם שמות (DNS), לא מתרגם IP ל-MAC (ARP), לא מנתב ולא מצפין.
ההקצאה עוברת ארבעה שלבים שמכונים DORA. כולם על UDP, השרת בפורט 67 והלקוח בפורט 68:
| שלב | השולח | מה בהודעה |
|---|---|---|
| Discover | הלקוח, בשידור | חיפוש שרת DHCP. מקור 0.0.0.0, יעד 255.255.255.255 |
| Offer | השרת | כתובת והגדרות שהוא מציע |
| Request | הלקוח, ובפעם הראשונה גם הוא בשידור | בקשה לקבל את ההצעה הזאת |
| Acknowledge | השרת | אישור, ומרגע זה הכתובת בשימוש הלקוח |
מחשב שמצטרף לרשת בלי כתובת פותח תמיד ב-Discover (לקוח שרק מחדש חכירה קיימת מדלג ישר ל-Request). במקור כתוב 0.0.0.0, משום שלמחשב עוד אין כתובת משלו. ביעד כתוב 255.255.255.255, משום שהוא לא יודע מי שרת ה-DHCP ואיפה הוא יושב.
- חכירה מתחדשת. לחכירה יש תוקף, והלקוח מחדש אותה בהודעה ישירה (Unicast) לשרת שהוא כבר מכיר.
- Relay Agent. שידור Discover נעצר בנתב. כששרת ה-DHCP יושב ברשת אחרת, ה-Relay Agent קולט את השידור ושולח אותו כהודעה ישירה לשרת. הוא לא מחלק כתובות בעצמו, לא מפיץ את השידור לכל הרשתות ולא עונה מהקצאות שזכר.
- שני שרתים עם טווחים חופפים באותו סגמנט. אף אחד מהם לא יודע מה השני חילק, ולכן שתי תחנות עלולות לקבל את אותה כתובת.
- Rogue DHCP server. שרת DHCP שאיש לא אישר, שמחלק לתחנות שער או שרת DNS בשליטת תוקף.
- אין תשובה מאף שרת. Windows בוחר לעצמו כתובת APIPA שמתחילה ב-
169.254, המסכה שלה היא255.255.0.0, ושדה השער נשאר ריק.
כתובת 169.254.x.x היא אם כן סימן לבעיית DHCP. היא לא טווח פרטי של NAT, לא טווח של DMZ, ואין לה קשר לשרת DNS שלא זמין.
תרחיש 5: מחשב נייד מצטרף לרשת של משרד קטן
- Discover: מקור
0.0.0.0, יעד255.255.255.255, ובשכבת Ethernet היעדFF:FF:FF:FF:FF:FF. - Offer מהנתב, שמשמש גם שרת DHCP: כתובת
10.0.0.57, שער10.0.0.1ושרתי DNS. - Request ואחריו Acknowledge. הכתובת בתוקף עד שהחכירה תפוג או תחודש.
- כדי לדבר עם השער המחשב צריך את ה-MAC שלו, ולכן הוא משדר ARP Request על
10.0.0.1, והנתב עונה. - מכאן אפשר לצאת לאינטרנט: שאילתת DNS, ואחריה חיבור לאתר.
ואם הנתב היה כבוי בשלב השני? אף Offer לא היה מגיע, המחשב היה נותן לעצמו כתובת 169.254.x.x, ובלי שער ברירת מחדל לא היה יוצא לאינטרנט.
ipconfig, ומה משתמשים במקומו ב-Linux
ipconfig היא פקודת Windows שמציגה את הגדרות הרשת של המחשב ומאפשרת לנהל חלק מהן. כל מתג נותן משהו אחר:
| פקודה | מה מקבלים |
|---|---|
ipconfig | לכל כרטיס: הכתובת, המסכה והשער. MAC ושרתי DNS לא מופיעים |
ipconfig /all | התמונה המלאה: שם הכרטיס, כתובת MAC, שרת ה-DHCP, מועדי החכירה ושרתי ה-DNS |
ipconfig /release | מוותרת על ההגדרות שהתקבלו מ-DHCP, והחיבור נקטע עד שמחדשים |
ipconfig /renew | פונה שוב לשרת DHCP ומבקשת כתובת |
ipconfig /flushdns | מרוקנת את מטמון ה-DNS של המחשב |
ipconfig /displaydns | מציגה מה יש במטמון ה-DNS |
/releaseו-/renewפועלות רק על כרטיס שמקבל את הכתובת שלו מ-DHCP./releaseלא קובעת כתובת קבועה, היא רק משחררת./flushdnsנוגעת רק במטמון המקומי. היא לא משנה את קובץhostsולא את המטמון בשרת של ספק האינטרנט.ipconfigלא יודע מה כתובת ה-IP הציבורית שלכם כפי שהעולם רואה אותה, לא מציג מהירות Wi-Fi ולא מציג טבלת ניתוב.
ב-Linux ובמק אין ipconfig, ומה שתקבלו הוא הודעת command not found:
ipconfigbash: line 1: ipconfig: command not foundב-Linux מציגים כתובות בפקודה ip addr. כך היא מתארת את ממשק ה-loopback:
ip addr show lo1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft foreverהפקודה הוותיקה יותר היא ifconfig, שקיימת גם ב-macOS. ו-arp -a לא תעזור כאן, כי היא מציגה את טבלת ה-ARP ולא את הכתובת של הכרטיס שלכם.
ההבדל בין ipconfig ל-ifconfig: הראשון בעיקר מציג מידע (כולל מצב DHCP ושם הדומיין) ומנהל חכירות ומטמון DNS. השני מאפשר גם להגדיר: להעלות ולהוריד ממשק (up/down) ולקבוע כתובות.
שינויים שעושים ב-ifconfig לא שורדים אתחול, ול-ipconfig אין אפשרות לערוך את טבלת הניתוב.
טעויות נפוצות
- ARP מקבל כתובת MAC ומחזיר את ה-IP ששייך לה. הכיוון הפוך: ARP מקבל IP ומחזיר MAC. מ-MAC ל-IP עשה RARP, שכבר לא בשימוש.
- ARP Request נשלח ישר לנתב, והנתב עונה עם ה-MAC של היעד. הבקשה משודרת לכל הרשת, והיעד עונה בעצמו. שואלים על ה-MAC של הנתב רק כשהיעד ברשת אחרת.
- נתב מעביר שידורים לכל הרשתות שמחוברות אליו. לא כברירת מחדל. תחום השידור נגמר בנתב.
- ב-DHCP Discover המקור הוא
255.255.255.255והיעד0.0.0.0. בדיוק הפוך. במקור יש0.0.0.0, מפני שאין עוד כתובת, וביעד255.255.255.255, מפני שהשרת לא ידוע. ipconfig /allמראה את כתובת ה-IP הציבורית. היא מראה את פרטי הכרטיסים המקומיים: MAC, DHCP ו-DNS. הכתובת הציבורית שייכת לנתב שמבצע NAT.ipconfig /releaseמחליפה את הכתובת בחדשה מיד. היא רק משחררת. את הכתובת החדשה מבקשים ב-/renew.169.254.x.xשייך לטווח פרטי רגיל של NAT. זו כתובת APIPA שהמחשב בחר לעצמו, כי שום שרת DHCP לא ענה.
בדקו את עצמכם
סטודנטית מחברת כבל רשת, מריצה ipconfig ורואה 169.254.88.3, מסכה 255.255.0.0 ושער ריק. מה קרה?
אף שרת DHCP לא ענה למחשב, ולכן הוא הקצה לעצמו כתובת APIPA. בלי שער ברירת מחדל הוא לא יגיע לאינטרנט.
איזה מתג של ipconfig מציג גם MAC, גם מי שרת ה-DHCP וגם מתי מתחילה ומסתיימת החכירה?
ipconfig /all.
שרת קבצים נמצא ברשת אחרת, מאחורי נתב. למה המחשב לא שולח ARP Request עם הכתובת של השרת?
כי ARP Request הוא שידור מקומי, ונתב לא מעביר שידורים. במקום זה המחשב מברר את ה-MAC של שער ברירת המחדל ושולח אליו.
Hub, Bridge ו-Switch: מי מעביר מה
Hub: משכפל בלי לקרוא
Hub (רכזת) שייך לשכבה הפיזית, שכבה 1. הוא לא מבין כתובות בכלל: אות שנכנס מפורט אחד יוצא מחדש מכל שאר הפורטים.
המשמעות: כל מחשב שומע את כל מה שנשלח, כל הפורטים חולקים תחום התנגשות אחד, והעבודה היא Half Duplex, כלומר אי אפשר לשלוח ולקבל באותו רגע. כל תחנה שמוסיפים מגדילה את כמות המסגרות שמגיעות לכולם, ואיתה את העומס ואת ההתנגשויות.
Hub לא מצפין, לא לומד כתובות MAC, לא מנתב לפי IP ולא משנה TTL. היום נשאר לו שימוש אחד: במעבדה, מחשב עם Wireshark שמחובר ל-Hub רואה כל מסגרת שעוברת בין המחשבים האחרים, בלי שום הגדרה בציוד.
חזרה לתוכן הענייניםBridge: לומד ומסנן לפי MAC
Bridge (גשר) פועל בשכבה 2, שכבת קישור הנתונים. הוא מחבר שני קטעי רשת, ולגבי כל מסגרת מחליט אם להעביר אותה, לפי כתובות MAC. הוא לא מנתב לפי IP ולא מתרגם כתובות.
הלמידה מתבססת על כתובת המקור בלבד. כשמסגרת מגיעה מפורט מסוים, הגשר רושם בטבלה שה-MAC הזה נמצא מאחורי הפורט הזה. כתובת היעד לא נרשמת, והגשר לא שולח ARP כדי לגלות משהו.
לגבי כל מסגרת יש שלוש אפשרויות:
- העברה: היעד כבר רשום מאחורי פורט אחר, והמסגרת יוצאת רק בו.
- סינון: היעד רשום מאחורי אותו פורט שממנו המסגרת הגיעה, כלומר באותו קטע, ולכן היא לא יוצאת לשום מקום.
- הצפה (Flooding): היעד עוד לא נלמד, או שזו מסגרת Broadcast או Multicast. המסגרת יוצאת מכל הפורטים חוץ מזה שממנו הגיעה, וכשהיעד יענה, הגשר ירשום גם אותו.
שימו לב למה שגשר לא עושה עם יעד לא מוכר: הוא לא זורק את המסגרת, לא מחזיק אותה ומחכה, ולא שולח אותה לנתב ברירת המחדל. הנה מודל קטן של גשר עם ארבעה פורטים, שמפעיל בדיוק את שלושת הכללים:
# A learning bridge with four ports, reduced to its decision rule
BROADCAST = "ff:ff:ff:ff:ff:ff"
PORTS = [1, 2, 3, 4]
table = {} # MAC -> port, starts empty
def frame(src, dst, in_port):
table[src] = in_port # learn from the SOURCE only
if dst != BROADCAST and dst in table:
out = table[dst]
if out == in_port:
action = "filter (same segment)"
else:
action = f"forward to port {out}"
else:
others = [p for p in PORTS if p != in_port]
action = f"flood to ports {others}"
print(f"{src} -> {dst} on port {in_port}: {action}")
frame("0a", "0b", 1) # 0b unknown yet
frame("0b", "0a", 3) # reply: 0a already learned
frame("0a", "0b", 1) # now both are known
frame("0c", "0a", 1) # 0c sits on the same segment as 0a
frame("0b", BROADCAST, 3) # broadcast always floods
print(table)0a -> 0b on port 1: flood to ports [2, 3, 4]
0b -> 0a on port 3: forward to port 1
0a -> 0b on port 1: forward to port 3
0c -> 0a on port 1: filter (same segment)
0b -> ff:ff:ff:ff:ff:ff on port 3: flood to ports [1, 2, 4]
{'0a': 1, '0b': 3, '0c': 1}המסגרת הראשונה הוצפה, כי 0b עוד לא היה מוכר. התשובה שלו לימדה את הגשר שהוא בפורט 3, ומאז התעבורה ביניהם הולכת ישר. 0c ו-0a יושבים שניהם מאחורי פורט 1, ולכן מסגרת ביניהם סוננה, והשידור הוצף כמו תמיד.
גשר מפצל את תחומי ההתנגשות, אבל מבחינת שידורים כל הקטעים שהוא מחבר נשארים תחום אחד. לכן גשר בין הרשת החוטית לרשת ה-Wi-Fi מאחד אותן: כל התחנות חולקות Broadcast Domain אחד וטווח כתובות אחד, ממש כמו בסגמנט יחיד.
Switch (מתג) הוא בעיקרון גשר עם הרבה פורטים, שמבצע את ההעברה בחומרה ולכן מהר יותר. זה כל ההבדל, מספר הפורטים והמהירות: שניהם בשכבה 2 ושניהם עובדים עם כתובות MAC.
חזרה לתוכן הענייניםתחום התנגשות ותחום שידור
| מושג | מה הוא מתאר |
|---|---|
| Collision Domain | קטע שבו כמה התקנים חולקים ערוץ אחד, ושידור בו זמנית של שניים מהם גורם להתנגשות |
| Broadcast Domain | כל ההתקנים ששומעים שידור שאחד מהם שלח, כל עוד אין נתב בדרך |
- Hub: תחום התנגשות אחד לכל הפורטים, וגם תחום שידור אחד.
- Bridge ו-Switch: כל פורט הוא תחום התנגשות נפרד, אבל כולם יחד הם תחום שידור אחד.
- נתב: מפריד גם בין תחומי שידור.
ארבעת ההתקנים בטבלה אחת
| התקן | שכבה | מה הוא עושה עם מה שמגיע | משנה TTL? |
|---|---|---|---|
| Hub | 1, פיזית | משכפל לכל שאר הפורטים | לא |
| Bridge | 2 | מעביר, מסנן או מציף לפי טבלת MAC | לא |
| Switch | 2 | כמו גשר, עם הרבה פורטים והעברה בחומרה | לא |
| נתב (Router) | 3 | מעביר חבילות בין רשתות לפי כתובת IP | כן, מוריד 1 בכל מעבר |
תרחיש 6: Wireshark על Hub ועל Switch
במעבדה מחוברות ל-Hub שלוש תחנות: X, Y ו-Z. תחנה X שולחת מסגרת ל-Y, ו-Z מריצה Wireshark במצב Promiscuous.
ה-Hub מוציא עותק של המסגרת בכל הפורטים חוץ מזה של X, ולכן היא מגיעה גם ל-Z, ו-Z לוכדת אותה.
מחליפים את ה-Hub ב-Switch שכבר יודע באיזה פורט נמצא Y. עכשיו המסגרת יוצאת רק לפורט של Y, ו-Z לא מקבלת אותה בכלל.
לכן לוכד שרץ על מחשב המחובר ל-Switch לא רואה תעבורה בין מחשבים אחרים, אלא אם מגדירים במתג Port Mirroring. ה-Switch לא הצפין שום דבר ולא הוריד TTL, ו-Wireshark לא נחסם: המסגרות פשוט לא נשלחו לפורט שלו.
טעויות נפוצות
- Switch עובד בשכבה הפיזית, ו-Hub בשכבת הרשת. שני החלקים שגויים. Hub שייך לשכבה 1 ו-Switch לשכבה 2.
- Hub קורא את כתובת היעד, MAC או IP, ושולח רק אליה. Hub לא קורא שום כתובת. הוא משכפל כל דבר לכל הפורטים.
- Bridge מנתב לפי IP ומפריד בין תחומי שידור. שני הדברים האלה הם עבודה של נתב. Bridge עובד עם MAC ומשאיר תחום שידור אחד.
- Bridge מחלק כתובות IP לתחנות שמתחברות. חלוקת כתובות היא תפקיד של DHCP.
- Switch מצפין את התעבורה בין הפורטים. Switch לא מצפין דבר. הוא רק בוחר לאיזה פורט לשלוח.
- Hub מוריד את ה-TTL במעבר. רק נתב נוגע ב-TTL. Hub לא מסתכל בכותרות בכלל.
- Hub מאפשר Full Duplex במהירות גבוהה. Hub עובד ב-Half Duplex, עם תחום התנגשות אחד.
- גשר לומד מכתובת היעד של המסגרת. הוא לומד מכתובת המקור, ורושם אותה ליד הפורט שממנו המסגרת הגיעה.
בדקו את עצמכם
לגשר עם שלושה פורטים מגיעה בפורט 2 מסגרת Unicast, וה-MAC של היעד שלה לא בטבלה. לאן היא יוצאת, ומה הגשר רושם?
היא יוצאת בפורטים 1 ו-3 (לא חזרה לפורט 2), והגשר רושם את ה-MAC של המקור ליד פורט 2.
למה מחשב שמחובר ל-Switch לא יכול להאזין בקלות לשיחות של אחרים?
כי ה-Switch מוציא בכל פורט רק מסגרות שהיעד שלהן נמצא מאחוריו, ובנוסף שידורים, אלא אם הוגדר Port Mirroring.
גשר מחבר רשת חוטית ורשת Wi-Fi. האם ARP Request ממחשב חוטי יגיע לטלפון ברשת האלחוטית?
כן. גשר משאיר את שתי הרשתות בתחום שידור אחד, ושידורים מוצפים לכל הפורטים.
NAT ו-DMZ: כתובת ציבורית אחת ואזור חיץ
NAT ו-PAT: הרבה מכשירים מאחורי כתובת אחת
מאגר כתובות IPv4 הציבוריות נגמר, ולכן ברשתות פנימיות משתמשים בטווחים פרטיים: 10.0.0.0/8, 172.16.0.0/12 ו-192.168.0.0/16. כתובות מהטווחים האלה לא מנותבות באינטרנט.
NAT (Network Address Translation) פועל בנתב: בדרך החוצה הוא מחליף את הכתובות הפנימיות בכתובת חיצונית אחת או יותר, ובדרך פנימה מחזיר אותן למקומן.
הצורה הנפוצה היא PAT, שנקראת גם NAT Overload: כל המכשירים יוצאים עם אותה כתובת ציבורית, והנתב מבחין ביניהם לפי מספרי הפורט שבטבלת התרגום. כך נתב ביתי אחד מחזיק עשרות מכשירים מאחורי כתובת ציבורית אחת.
# Port Address Translation on a home router with one public address
PUBLIC = "198.51.100.7"
table = {} # public port -> (inside address, inside port)
next_port = 61000
def outgoing(inside_ip, inside_port, dest):
global next_port
public_port = next_port
next_port += 1
table[public_port] = (inside_ip, inside_port)
print(f"out: {inside_ip}:{inside_port} -> {dest} becomes {PUBLIC}:{public_port} -> {dest}")
def incoming(public_port):
if public_port in table:
ip, port = table[public_port]
print(f"in: reply to {PUBLIC}:{public_port} delivered to {ip}:{port}")
else:
print(f"in: packet to {PUBLIC}:{public_port} dropped, no entry in the table")
outgoing("10.0.0.21", 49152, "203.0.113.80:443") # laptop
outgoing("10.0.0.35", 49152, "203.0.113.80:443") # phone, same source port
incoming(61001)
incoming(61000)
incoming(5060) # a call that starts outsideout: 10.0.0.21:49152 -> 203.0.113.80:443 becomes 198.51.100.7:61000 -> 203.0.113.80:443
out: 10.0.0.35:49152 -> 203.0.113.80:443 becomes 198.51.100.7:61001 -> 203.0.113.80:443
in: reply to 198.51.100.7:61001 delivered to 10.0.0.35:49152
in: reply to 198.51.100.7:61000 delivered to 10.0.0.21:49152
in: packet to 198.51.100.7:5060 dropped, no entry in the tableהמחשב הנייד והטלפון יצאו מאותו פורט מקור, 49152, ובכל זאת כל תשובה הגיעה למכשיר הנכון: הנתב נתן לכל חיבור פורט חיצוני משלו, ובתשובה חיפש את הפורט הזה בטבלה. החבילה האחרונה הגיעה מבחוץ לפורט שאין לו רשומה, ולכן לא היה לנתב לאן להעביר אותה.
מה NAT לא עושה: הוא לא נותן לכל מכשיר כתובת ציבורית משלו, ולא מבחין בין מכשירים לפי MAC או לפי מפתחות הצפנה. הוא לא מצפין (זה תפקיד של VPN או HTTPS), הוא לא חומת אש, והוא לא פותח כלפי חוץ את כל הפורטים של הרשת הפנימית. הוא גם לא מחלק כתובות, זו עבודה של DHCP.
הכלל המרכזי: חיבור שנפתח מבפנים יוצר רשומה בטבלה, והתשובה חוזרת לפיה. לחיבור שנפתח מבחוץ אין רשומה, ולכן צריך Port Forwarding, הגדרה שאומרת לנתב להעביר את מה שמגיע לפורט חיצוני מסוים אל פורט מסוים במחשב פנימי מסוים.
בלי מיפוי נכון, בקשות מהאינטרנט לא יגיעו לשרת הפנימי, ואין טעם לקוות שהנתב ינחש לבד למי הן מיועדות.
חזרה לתוכן הענייניםסוגי NAT, ולמה Peer-to-Peer מתקשה
- Static NAT: כתובת פנימית אחת ממופה תמיד לאותה כתובת חיצונית, אחד לאחד.
- Dynamic NAT: הכתובת החיצונית נלקחת ממאגר של כתובות, ולכן היא יכולה להשתנות.
- PAT: כתובת חיצונית אחת לכולם, והפורט הוא שמבחין.
סיווג אחר מתאר עד כמה המיפוי פתוח לתעבורה שנכנסת מבחוץ:
- Full Cone NAT: ברגע שנפתח מיפוי לפורט, כל כתובת חיצונית יכולה לשלוח אליו.
- Symmetric NAT: לכל יעד נפתח מיפוי נפרד, ורק הצד שאליו פנו יכול לענות דרכו. זה הסוג הקשה ביותר ליישומי Peer-to-Peer.
- Restricted Cone וסוגים דומים נמצאים בין שני הקצוות.
מכאן הקושי של Peer-to-Peer ושל VoIP מאחורי NAT ב-IPv4: כשהצד השני מנסה לפתוח חיבור מבחוץ, אין בטבלת התרגום רשומה שתגיד לנתב לאיזה מחשב פנימי להעביר אותו. הבעיה איננה ש-NAT חוסם UDP, מגביל את מספר החיבורים או נותן לכולם אותה כתובת פרטית.
חזרה לתוכן הענייניםDMZ: אזור נפרד לשרתים הפתוחים לציבור
DMZ (Demilitarized Zone) הוא מקטע רשת נפרד, ובו יושבים השרתים שהציבור צריך להגיע אליהם, כמו אתר, שרת דואר או DNS. כללי חומת אש מפרידים אותו מהרשת הפנימית.
ההיגיון: שרת שפתוח לאינטרנט הוא הראשון שתוקפים ינסו לפרוץ. אילו ישב ברשת הפנימית, פריצה אליו הייתה פותחת לתוקף את כל הארגון, וכשהוא ב-DMZ, חומת האש מקשה על התוקף להמשיך פנימה.
מקימים DMZ בעזרת זוג חומות אש שהוא יושב ביניהן, או בעזרת חומת אש אחת שה-DMZ מחובר לממשק השלישי שלה. ה-DMZ לא מצפין, לא אוסף לוגים ולא מחליף את הנתב ביציאה של התחנות לאינטרנט.
הוא גם לא פוטר מהקשחה: השרתים בו חשופים לציבור, ולכן צריך להקשיח אותם היטב.
- שרת אתר שגולשים פונים אליו: ב-DMZ. בסיס הנתונים שרק שרת האתר משתמש בו: ברשת הפנימית.
- Domain Controller של Active Directory מחזיק את חשבונות המשתמשים וההרשאות של כל הארגון. לא שמים אותו ב-DMZ כדי לאפשר גישה מבחוץ, כי מי שיפרוץ אליו יקבל דריסת רגל בכל הרשת הפנימית.
זהירות: אותו שם משמש בנתבים ביתיים לדבר אחר. 'DMZ host' שם מעביר למכשיר פנימי אחד את כל התעבורה הנכנסת שאין לה יעד מוגדר אחר.
זה לא מקטע מבודד אלא חשיפה של המכשיר הזה לכל מה שמגיע מבחוץ, ולכן זה מסוכן יותר.
תרחיש 7: חנות מקוונת: מי יושב איפה
לחברה יש אתר מכירות ובסיס נתונים של הזמנות, שרק האתר פונה אליו. את האתר מציבים ב-DMZ, וחומת האש מתירה לו לפנות פנימה רק לבסיס הנתונים, ורק בפורט שהוא צריך.
בסיס הנתונים יושב ברשת הפנימית, ואין אליו גישה ישירה מהאינטרנט. אם תוקף ישתלט על שרת האתר, חוקי חומת האש עדיין עומדים בינו לבין שאר המחשבים בארגון.
באותו זמן העובדים גולשים באינטרנט דרך הנתב: הכתובות הפרטיות שלהם מתורגמות ב-PAT לכתובת ציבורית אחת, ומספרי הפורט מבדילים בין החיבורים.
טעויות נפוצות
- NAT מצפין את התעבורה או מסנן תעבורה זדונית. NAT רק מחליף כתובות ופורטים. הצפנה היא VPN או HTTPS, וסינון הוא חומת אש.
- NAT מחלק כתובות למכשירים שמתחברים. זו עבודה של DHCP.
- Static NAT מתרגם בין IPv4 ל-IPv6, או דורש מנהרת VPN. Static NAT הוא פשוט מיפוי קבוע של כתובת פנימית אחת לכתובת חיצונית אחת.
- DMZ מצפינה את התעבורה או מתעדת אותה. DMZ היא מקטע רשת מבודד, לא מנגנון הצפנה ולא מערכת לוגים.
- DMZ היא הרשת המוגנת שבה יושבות תחנות העבודה. הפוך: DMZ מיועדת לשרתים הפתוחים לציבור, ותחנות העבודה נמצאות ברשת הפנימית.
- 'DMZ host' בנתב הביתי הוא אותו דבר כמו DMZ ארגונית. DMZ host פותח מכשיר בודד לכל התעבורה הנכנסת. DMZ אמיתית היא מקטע נפרד ומבודד.
- שרת שנמצא ב-DMZ מוגן מספיק, אז אפשר לוותר על הקשחה שלו. השרת ב-DMZ חשוף לאינטרנט, ולכן דווקא הוא צריך הקשחה קפדנית.
בדקו את עצמכם
בארגון יש שרת DNS ציבורי לדומיין שלו ושרת גיבויים של מחשבי העובדים. איפה ממקמים כל אחד?
את שרת ה-DNS הציבורי ב-DMZ, כי הוא צריך להיות נגיש מהאינטרנט. את שרת הגיבויים ברשת הפנימית.
שרת משחק שמריצים בבית לא מקבל חיבורים מחברים באינטרנט, אף שבתוך הבית הוא עובד מצוין. מה חסר?
Port Forwarding בנתב. החיבורים מתחילים מבחוץ, ולכן אין להם רשומה בטבלת ה-NAT, והנתב לא יודע לאיזה מחשב להעביר אותם.
בסימולציה שלמעלה, למה התשובה ל-198.51.100.7:61001 הגיעה לטלפון ולא למחשב הנייד, אף ששניהם יצאו מפורט 49152?
כי הנתב הבדיל ביניהם בפורט החיצוני: 61000 נרשם למחשב הנייד ו-61001 לטלפון.
Socket, bind/listen/accept ו-SYN/ACK: איך נפתח חיבור TCP
Socket: נקודת הקצה, ומה בעצם מזהה חיבור
תוכנה שרוצה לתקשר ברשת לא מדברת ישירות עם כרטיס הרשת. היא מבקשת ממערכת ההפעלה Socket, כלומר נקודת קצה של תקשורת, שמזוהה בזוג ערכים, כתובת IP ופורט, יחד עם הפרוטוקול שמעליו (TCP או UDP).
כדאי לזכור גם מה Socket אינו: לא כתובת ה-MAC של הכרטיס, לא מספר התהליך (PID) שהמערכת נתנה לתוכנה, ולא פורט שעומד לבדו בלי הכתובת שהוא שייך לה.
חיבור TCP שלם מזוהה ברמה אחת מעל: ברביעייה (4-tuple) שמורכבת מ-IP המקור, פורט המקור, IP היעד ופורט היעד. מספיק שאחד מארבעת הערכים שונה, וכבר מדובר בחיבור אחר.
| מועמד לזיהוי החיבור | מספיק? | הסיבה |
|---|---|---|
| כתובות MAC | לא | הן שייכות לשכבה 2 ורלוונטיות רק בתוך הרשת המקומית, ולא מבחינות בין שתי שיחות של אותו מחשב |
| פורט השרת לבדו | לא | כל משתמשי השירות פונים לאותו פורט בדיוק |
| שתי כתובות IP בלי פורטים | לא | מאותו מחשב אפשר לפתוח כמה חיבורים במקביל אל אותו שרת |
| מספר ה-Sequence ההתחלתי | לא | זה מונה בתים בתוך חיבור קיים, לא השם שלו |
| הרביעייה המלאה | כן | שני חיבורים שונים תמיד נבדלים לפחות באחד מארבעת הרכיבים |
מכאן גם ההסבר לשאלה איך שירות אחד על פורט 443 מטפל באלפי משתמשים באותו רגע. השרת לא פותח פורט נוסף לכל משתמש: כל חיבור מקבל Socket משלו, וכל ה-Sockets האלה חולקים את פורט השרת ונבדלים בכתובת ובפורט המקור של הלקוח.
ומי בוחר את פורט המקור? בדרך כלל לא הלקוח. ברגע שהתוכנה קוראת ל-connect, מערכת ההפעלה מצמידה לה פורט זמני (Ephemeral) פנוי, שחוזר למאגר כשהחיבור נסגר.
כשיוצרים Socket מציינים איזה סוג תקשורת הוא ישרת:
| סוג ה-Socket | אופי התקשורת | הפרוטוקול כברירת מחדל ב-IPv4 |
|---|---|---|
| SOCK_STREAM | זרם רציף של בתים | TCP |
| SOCK_DGRAM | הודעות נפרדות (Datagram), כל אחת עומדת בפני עצמה | UDP |
ארבע הקריאות: bind, listen, accept ו-connect
שרת TCP עובר שלושה שלבים קבועים, ותמיד בסדר הזה: קודם bind, אחריו listen, ורק בסוף accept. ללקוח מספיקה קריאה אחת, connect, והיא זו שמניעה את לחיצת היד.
| קריאה | באיזה צד | מה היא עושה |
|---|---|---|
| bind() | שרת | מצמידה את ה-Socket לכתובת IP ולפורט של המחשב המקומי, וכך נקבע היכן בדיוק השירות יחכה לפניות |
| listen() | שרת | מעבירה את ה-Socket למצב פסיבי של קבלת פניות, וקובעת Backlog: כמה חיבורים שכבר הושלמו הליבה תשמור בתור עד שהתוכנה תאסוף אותם |
| accept() | שרת | שולפת מהתור חיבור מוכן ומחזירה עבורו Socket חדש, בזמן ש-Socket ההאזנה ממשיך במשימתו. כשהתור ריק היא נחסמת וממתינה |
| connect() | לקוח | מתחילה את הקמת החיבור מול הכתובת והפורט של השרת |
בדוגמה הבאה (Python 3 על Linux) שרת ושני לקוחות רצים באותו תהליך. שימו לב לסדר: שני הלקוחות מסיימים connect עוד לפני שהשרת קרא ל-accept ולו פעם אחת.
import socket
lobby = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
lobby.bind(("127.0.0.1", 7310)) # local address + port of the server
lobby.listen(3) # passive socket, backlog of 3
print("listener:", lobby.getsockname())
# two clients connect BEFORE the server ever calls accept()
anna = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
anna.connect(("127.0.0.1", 7310)) # the OS picks an ephemeral source port
ben = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ben.connect(("127.0.0.1", 7310))
print("connect() returned for both, accept() not called yet")
for _ in range(2):
conn, peer = lobby.accept() # takes a finished connection from the queue
print("new socket", conn.getsockname(), "<->", peer,
"| same fd as listener:", conn.fileno() == lobby.fileno())
print("listener still bound to", lobby.getsockname())listener: ('127.0.0.1', 7310)
connect() returned for both, accept() not called yet
new socket ('127.0.0.1', 7310) <-> ('127.0.0.1', 46494) | same fd as listener: False
new socket ('127.0.0.1', 7310) <-> ('127.0.0.1', 46504) | same fd as listener: False
listener still bound to ('127.0.0.1', 7310)קראו את הפלט לפי הסדר. השורה השנייה מודפסת לפני כל accept, ולכן ברור שמי שהשלים את לחיצת היד הוא הליבה, ו-accept רק אוספת מהתור חיבור שכבר מוכן. בשורות של accept צד השרת זהה (7310), פורטי הלקוחות שונים ונבחרו בידי המערכת (בהרצה שלכם יהיו אחרים), וה-False מראה שבכל פעם התקבל מתאר חדש ולא ה-Socket המאזין.
שימו לב גם למה שהקוד לא היה צריך. הלקוחות לא קראו ל-bind, ו-accept לא חיכתה לזה וגם לא פנתה אליהם ב-connect, כי היא לא יוזמת דבר מול הלקוח. והמספר 3 שהועבר ל-listen אינו מה שמפעיל את ההאזנה: הוא רק התקרה של תור החיבורים שממתינים לאיסוף.
ב-UDP התמונה פשוטה עוד יותר, כי אין חיבור שצריך לנהל. השרת הבא מסתפק ב-bind, ממתין להודעה ב-recvfrom ועונה ב-sendto לכתובת שממנה היא הגיעה; listen, accept ו-connect פשוט לא מופיעים.
import socket
meter = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
meter.bind(("127.0.0.1", 6300)) # bind only: no listen, no accept
probe = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
probe.sendto(b"temp?", ("127.0.0.1", 6300)) # no handshake, the datagram just goes
data, sender = meter.recvfrom(512)
print("got", data, "from", sender)
meter.sendto(b"21.5C", sender)
print("reply:", probe.recvfrom(512)[0])got b'temp?' from ('127.0.0.1', 47239)
reply: b'21.5C'כש-bind נכשל: שלוש שגיאות שונות
bind לא מתפשר. אם הפורט שביקשתם תפוס, הוא לא יחפש לכם פורט אחר אלא פשוט ייכשל, והודעת השגיאה מספרת מה בדיוק השתבש. כך זה נראה ב-Linux, אצל משתמש רגיל בלי הרשאות root:
import socket
def try_bind(label, addr):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.bind(addr)
print(label, "-> ok, bound to", s.getsockname())
return s
except OSError as e:
print(label, "->", e)
first = try_bind("first server, port 6100", ("0.0.0.0", 6100))
first.listen(5)
try_bind("second server, same port", ("0.0.0.0", 6100))
try_bind("address not on any interface", ("10.77.77.77", 6101))
try_bind("port 443 as a normal user", ("0.0.0.0", 443))first server, port 6100 -> ok, bound to ('0.0.0.0', 6100)
second server, same port -> [Errno 98] Address already in use
address not on any interface -> [Errno 99] Cannot assign requested address
port 443 as a normal user -> [Errno 13] Permission denied| השגיאה | מה גרם לה |
|---|---|
| Address already in use | הצירוף של הכתובת והפורט כבר תפוס: תהליך אחר משתמש בו, או שחיבור קודם עליו עוד לא שוחרר |
| Cannot assign requested address | ביקשתם כתובת IP שאינה מוגדרת על אף ממשק של המחשב |
| Permission denied | ב-Unix פורט מתחת ל-1024 דורש הרשאות, ומשתמש רגיל נדחה |
המקרה הקלאסי של Address already in use הוא דווקא השרת שלכם עצמו: עצרתם אותו והפעלתם מחדש מיד, ועל הפורט עוד תלוי חיבור ישן במצב TIME_WAIT. הפתרון המקובל הוא להפעיל את האפשרות SO_REUSEADDR לפני ה-bind:
import socket
def start(port, reuse):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if reuse:
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(("127.0.0.1", port))
s.listen(5)
return s
def serve_once_then_restart(port, reuse):
srv = start(port, reuse)
cli = socket.create_connection(("127.0.0.1", port))
conn, _ = srv.accept()
conn.close() # the server closes first, so its side stays in TIME_WAIT
cli.close()
srv.close()
try:
start(port, reuse) # restart right away
print("SO_REUSEADDR", reuse, "-> restart ok")
except OSError as e:
print("SO_REUSEADDR", reuse, "->", e)
serve_once_then_restart(6201, reuse=False)
serve_once_then_restart(6202, reuse=True)SO_REUSEADDR False -> [Errno 98] Address already in use
SO_REUSEADDR True -> restart okב-Linux האפשרות עוזרת רק אם הופעלה גם בהרצה הקודמת, ולכן נהוג להגדיר אותה בכל שרת כבר מההתחלה.
תרחיש 8: שני לקוחות על אותו פורט שרת
שירות מלאי מאזין ב-172.16.4.20:5000. מחשב הקופה (10.8.0.31) ומחשב המחסן (10.8.0.32) מתחברים אליו, ובמקרה מערכת ההפעלה של שניהם בחרה אותו פורט מקור, 49152.
| צד השרת | צד הלקוח | |
|---|---|---|
| החיבור של הקופה | 172.16.4.20:5000 | 10.8.0.31:49152 |
| החיבור של המחסן | 172.16.4.20:5000 | 10.8.0.32:49152 |
איך השרת יודע לאיזה חיבור שייכת כל מנה שנכנסת? הוא משווה את כל ארבעת הערכים. כאן שלושה מהם זהים בשני החיבורים, ורק כתובת הלקוח (31 מול 32) מכריעה, וזה מספיק כדי ש-accept תיתן לכל אחד Socket משלו.
וה-Socket שקיבל את הפניות? הוא לא עבר לטפל באף לקוח, ועדיין מחכה לבאים בתור. מי שכן ייתקע הוא עותק נוסף של שירות המלאי שינסה לעלות באותו מחשב על 172.16.4.20:5000: ה-bind שלו יחזיר Address already in use.
לחיצת היד המשולשת: SYN, SYN-ACK, ACK
TCP לא מעביר אף בית של נתונים לפני ששני הצדדים הסכימו שיש ביניהם חיבור. ההסכמה הזו נבנית בשלוש הודעות (Three-Way Handshake), ורק בסדר אחד:
- SYN מהלקוח: בקשה לפתוח חיבור, ובה מספר ה-Sequence שממנו הלקוח מתחיל למנות, נקרא לו x.
- SYN-ACK מהשרת: חבילה אחת עם שני דגלים. היא מאשרת את ה-SYN עם Ack=x+1, ובאותה הזדמנות שולחת SYN של השרת עם מספר התחלתי משלו, y.
- ACK מהלקוח: Seq=x+1 ו-Ack=y+1. מעכשיו שני הצדדים במצב ESTABLISHED ואפשר להתחיל להעביר נתונים.
בסוף התהליך כל צד יודע מאיזה מספר השני מתחיל, וזה מה שמאפשר לסדר את המנות ולזהות מנות חסרות. ולמה ה-Ack הוא המספר שהתקבל ועוד אחד? כי SYN, וגם FIN, תופסים כל אחד מספר Sequence אחד, כאילו היו בית של נתונים.
Client -> Server SYN Seq=7000
Server -> Client SYN-ACK Seq=52000 Ack=7001
Client -> Server ACK Seq=7001 Ack=52001במציאות מספרי ההתחלה נבחרים באקראי. Wireshark מציג כברירת מחדל מספרים יחסיים, שבהם כל צד סופר מאפס: ה-SYN מופיע עם Seq=0, ה-SYN-ACK עם Seq=0 ו-Ack=1, וה-ACK שסוגר את הלחיצה עם Seq=1 ו-Ack=1.
ל-UDP אין שלב כזה בכלל: כבר ההודעה הראשונה נושאת נתונים, כמו שראיתם בדוגמת ה-UDP למעלה.
טעויות נפוצות
- הלקוח שולח SYN, מקבל ACK, ואחר כך מגיע SYN-ACK. הסדר היחיד הוא SYN, SYN-ACK, ACK. גם סדר שמתחיל ב-SYN-ACK, או שני SYN ואחריהם ACK, שגוי.
- ה-SYN הוא הבקשה של מחשב חדש לקבל כתובת IP. זה תפקיד של DHCP. SYN מבקש לפתוח חיבור TCP בין שתי כתובות שכבר קיימות.
- SYN-ACK הן שתי חבילות נפרדות, או אותה חבילה שנשלחת פעמיים ליתר ביטחון. זו חבילה אחת שבה דולקים שני דגלים, SYN ו-ACK.
- FIN משמש לפתיחת החיבור. FIN סוגר חיבור. הפתיחה נעשית ב-SYN.
- בתשובה ל-SYN, השרת מחזיר Ack שווה בדיוק ל-Seq שקיבל. ה-SYN תופס מספר אחד, ולכן Ack הוא ה-Seq שהתקבל ועוד 1.
פורט סגור, SYN Flood וסריקת SYN
מה קורה כש-SYN מגיע לפורט שאף תוכנה לא מאזינה עליו, וגם שום חומת אש לא מפריעה? הליבה בשרת עונה מיד ב-RST (ב-Wireshark תראו RST, ACK), וניסיון החיבור נדחה. לא יחזור SYN-ACK, לא FIN ולא ACK רגיל.
חומת אש משנה את התמונה. היא יכולה להשליך את ה-SYN בשקט, ואז הלקוח מחכה עד שהזמן נגמר, או לדחות אותו בהודעת ICMP unreachable; סורק פורטים יסמן פורט כזה כ-filtered, ואילו תשובת RST נראית לו כפורט closed.
| מה חזר אחרי ה-SYN | מה מסיקים |
|---|---|
| SYN-ACK | הפורט פתוח ותוכנה מאזינה עליו |
| RST (RST, ACK) | הפורט סגור: אין מאזין, ואין חומת אש שמסתירה זאת |
| שום דבר, עד שנגמר זמן ההמתנה | כנראה חומת אש השליכה את ה-SYN (filtered) |
| ICMP unreachable | חומת אש דחתה את הבקשה במפורש (filtered) |
בהתקפת SYN Flood התוקף מציף את השרת ב-SYN ולעולם לא שולח את ה-ACK שאמור לסגור את הלחיצה. כל ניסיון כזה תופס מקום בתור החיבורים החצי-פתוחים (מצב SYN_RECEIVED), התור מתמלא, ולקוחות אמיתיים נשארים בחוץ. אין כאן שום קשר ל-DNS או ל-FIN, וגם לא לחיבורים שהושלמו.
ההגנה הקלאסית נקראת SYN Cookies: השרת ממשיך לענות SYN-ACK כרגיל, אבל לא רושם דבר בטבלת החיבורים עד שה-ACK של הלקוח מגיע. הגדלת ה-Backlog היא לא ההגנה הזו, והשרת גם לא מוותר על שליחת ה-SYN-ACK.
גם סורקים משתמשים בלחיצת היד. SYN Scan (למשל ב-nmap) שולח SYN לכל פורט ומסתפק בתשובה: SYN-ACK פירושו פתוח, RST פירושו סגור, והחיבור עצמו אף פעם לא מושלם.
מהתשובה לומדים אם הפורט פתוח או סגור, אבל לא מה השירות שמאחוריו מחזיר. הסריקה גם לא עוקפת חומת אש, ואינה דרך לבדוק פורטי UDP.
תרחיש 9: שלוש לכידות של אותו ניסיון חיבור
מחשב שולח SYN עם Seq=2500 לפורט 8443 בשרת. בשלוש הרצות שונות נלכדו שלוש תגובות שונות.
- הרצה א: חוזר SYN-ACK עם Ack=2501, והלקוח משיב ACK. הפורט פתוח והחיבור קם. שימו לב לערך: 2501, לא 2500, לא 2502 ולא 0.
- הרצה ב: במקום SYN-ACK חוזר RST. על הפורט הזה אין שום תוכנה מאזינה.
- הרצה ג: לא חוזר כלום, הלקוח שולח שוב את ה-SYN, ובסוף מתייאש כשנגמר הזמן. ההסבר הסביר הוא חומת אש שמשליכה את הבקשה.
טעויות נפוצות
- השרת קורא קודם ל-listen ורק אחר כך ל-bind, או ל-connect ואז ל-bind. בשרת הסדר קבוע: bind, listen, accept. את connect מפעיל הלקוח.
- bind קושר את ה-Socket לכתובת ה-MAC, או רושם את השרת ב-DNS. bind קובע כתובת IP ופורט מקומיים, ותו לא.
- listen היא זו שמקבלת את החיבור, ו-accept היא שמאזינה. בדיוק להפך: listen מכינה את התור, ו-accept שולפת ממנו חיבור.
- accept מחזירה את ה-Socket המאזין, שעובר לטפל בלקוח. היא מחזירה Socket חדש, והמאזין נשאר להאזין.
- Socket מזוהה לפי מספר התהליך או לפי כתובת ה-MAC. הוא מזוהה לפי כתובת IP ופורט.
- די בפורט של השרת כדי לזהות חיבור. חיבור מזוהה ברביעייה, וכל הלקוחות חולקים את פורט השרת.
בדקו את עצמכם
שירות דואר מאזין על פורט 993 ומחזיק כרגע חיבורים פתוחים מ-25 משתמשים. כמה Sockets פתוחים לתהליך, ובמה נבדלים Sockets החיבורים זה מזה?
26: עשרים וחמישה Sockets של חיבורים ועוד Socket האזנה אחד. Sockets החיבורים נבדלים בכתובת ה-IP ובפורט המקור של כל משתמש.
שלחתם SYN לפורט 9999 במחשב שאין עליו מאזין ואין לפניו חומת אש. מה יחזור? ומה תראו אם חומת אש הייתה משליכה את הבקשה?
יחזור RST. אם חומת אש משליכה את ה-SYN, לא יחזור דבר והניסיון יסתיים כשייגמר זמן ההמתנה.
SYN יצא עם Seq=880. איזה Ack תמצאו ב-SYN-ACK?
Ack=881, כי ה-SYN תופס מספר Sequence אחד.
ICMP, TTL ו-Trace: איפה החבילה נתקעה
ICMP ו-ping: ערוץ הבקרה של IP
ICMP (Internet Control Message Protocol) הוא ערוץ ההודעות של שכבת IP: דרכו נתבים ומארחים מדווחים על תקלות ועונים לבדיקות. הודעת ICMP נארזת ישירות בתוך חבילת IP, ואין בה פורטים בכלל.
| Type | שם | מי שולח ומתי |
|---|---|---|
| 8 | Echo Request | המחשב הבודק, כבקשת ping אל היעד |
| 0 | Echo Reply | היעד, כתשובה לבקשה |
| 3 | Destination Unreachable | מי שלא הצליח להעביר את המנה הלאה, נתב בדרך או היעד עצמו, ומחזיר הודעה לשולח. קודים: 0 רשת, 1 מארח, 3 פורט |
| 11 | Time Exceeded | הנתב שאצלו ה-TTL ירד ל-0 והמנה נזרקה |
| 5 | Redirect | נתב שמודיע ללקוח שליעד הזה יש נתב אחר, מתאים יותר |
ping עושה דבר אחד: שולח Echo Request ומחכה ל-Echo Reply, וכך מגלים אם היעד מגיב וכמה זמן נמשך הסבב (RTT). הוא לא רץ מעל TCP או UDP, ולכן לא אומר דבר על פורטים פתוחים; הוא גם לא מודד קצב העברה מרבי, לא מתרגם שמות ולא מאזין לתעבורה.
ב-Windows יש שתי הודעות כישלון שונות, וכדאי להבחין ביניהן:
- Request timed out: שום תשובה לא חזרה. הבקשה נחסמה, סוננה בדרך, או שהיעד כבוי.
- Destination host unreachable: דווקא חזרה תשובה, הודעת ICMP מסוג 3, בדרך כלל מהנתב המקומי.
מחשב שעובד ובכל זאת שותק ל-ping? הסיבה השכיחה היא חומת אש שלא מכניסה Echo Request, וחומת האש של Windows נוהגת כך כברירת מחדל בפרופיל רשת ציבורית. פורט 80 סגור, DNS שנפל או לחיצת יד TCP שלא הושלמה אינם הסבר, כי ping לא משתמש באף אחד מהם.
ומה אם השם שנתתם ל-ping לא מתורגם ב-DNS? אז לא יוצאת אף הודעת ICMP, והפקודה נעצרת עוד קודם עם שגיאת שם (הרצה אמיתית ב-Windows):
C:\> ping -n 1 printer-lab.invalidPing request could not find host printer-lab.invalid. Please check the name and try again.תרחיש 10: ping נכשל, האתר עולה
מנהלת רשת מריצה ping portal.example.net ומקבלת שוב ושוב Request timed out. באותו רגע הדפדפן שלה טוען את הפורטל בלי שום עיכוב.
| מה רואים | מה זה מלמד |
|---|---|
| ping הציג ליד השם כתובת IP לפני שהתחיל להמתין | השם תורגם, כך שה-DNS עובד |
| הדפדפן מקבל את העמוד | יש נתיב תקין עד השרת, ופורט האתר (80 או 443) מקבל חיבורי TCP |
| לא חזרה שום הודעה, גם לא Time Exceeded | הבקשה לא נזרקה בדרך בגלל TTL; פשוט אף אחד לא ענה לה |
מה שנשאר הוא ש-Echo Request נבלע: השרת עצמו, או חומת אש שלפניו, לא מעבירים ICMP. לכן תוצאה שלילית של ping היא רמז בלבד, ולא פסק דין שהשרת כבוי.
TTL: מונה הקפיצות שבכותרת IP
TTL (Time To Live) הוא שדה של 8 ביטים בכותרת של חבילת IP, ולכן הערך הגבוה ביותר שלו הוא 255. כל נתב שמעביר את החבילה מוריד ממנו 1, ונתב שמוריד אותו ל-0 זורק את החבילה ושולח למקור ICMP Time Exceeded (Type 11).
למה צריך מונה כזה? כשיש לולאת ניתוב, נתב א' שולח לנתב ב' ונתב ב' מחזיר לא', חבילה הייתה מסתובבת ביניהם בלי סוף; ה-TTL מבטיח שאחרי מספר סופי של נתבים היא תיעלם.
השם Time To Live מטעה, ולכן כדאי לדעת מה השדה הזה לא מייצג:
- זמן בשניות: אף נתב לא מסתכל על שעון, הוא רק מחסיר 1.
- קצב או רוחב פס: לשדה אין שום השפעה על מהירות ההעברה.
- ניסיונות שליחה חוזרים: את זה מנהל TCP, ולא כותרת IP.
- כתובת היעד: יש לה שדה נפרד בכותרת.
מי לא נוגע ב-TTL? Hub, Bridge ו-Switch מעבירים את החבילה בלי לשנות אותו. גם ל-ARP אין TTL, כי הודעת ARP בכלל לא נארזת בחבילת IP.
| מערכת | ערך TTL התחלתי נפוץ |
|---|---|
| Linux, macOS, Android | 64 |
| Windows | 128 |
| הרבה התקני רשת | 255 |
את ערכי ההתחלה רואים יפה ב-ping אל כתובת הלולאה של המחשב עצמו, כשאין אף נתב בדרך. פעם ב-Windows:
C:\> ping -n 1 127.0.0.1Pinging 127.0.0.1 with 32 bytes of data:
Reply from 127.0.0.1: bytes=32 time<1ms TTL=128
Ping statistics for 127.0.0.1:
Packets: Sent = 1, Received = 1, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 0ms, Maximum = 0ms, Average = 0msופעם ב-Linux (WSL על אותו מחשב):
ping -c 1 127.0.0.1PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data.
64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.043 ms
--- 127.0.0.1 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.043/0.043/0.043/0.000 msכשהתשובה מגיעה ממחשב רחוק, ה-TTL שמודפס הוא מה שנותר בחבילת התשובה כשהגיעה אליכם: ערך ההתחלה של המשיב, פחות מספר הנתבים שבדרך. במילים אחרות, כמה קפיצות נוספות החבילה הזו עוד הייתה יכולה לעבור.
מכאן נובע ניחוש מקובל של מערכת ההפעלה בצד השני: TTL=57 מרמז על התחלה מ-64, ו-TTL=115 על התחלה מ-128. זו היוריסטיקה בלבד ולא הוכחה.
traceroute ו-tracert: מיפוי הנתבים בדרך
Trace חושף את הנתבים שבין המחשב שלכם לבין היעד: ב-Windows הפקודה היא tracert, וב-Linux traceroute. הוא בנוי כולו על TTL: שולח בדיקה עם TTL=1, אחריה עם TTL=2, אחר כך 3, וממשיך כך.
הבדיקה עם TTL=1 נזרקת בנתב הראשון, והוא מחזיר Time Exceeded וחושף בכך את כתובתו; הבדיקה עם TTL=2 נזרקת בנתב השני, וכך הלאה עד היעד. לכל קפיצה (Hop) נשלחות שלוש בדיקות, ולכן בכל שורה מופיעים שלושה זמני תגובה.
הכתובת שמוצגת בכל שורה היא מקור התשובה, בדרך כלל הממשק שדרכו הבדיקה נכנסה לנתב.
| tracert (Windows) | traceroute (Linux) | |
|---|---|---|
| מה נשלח כברירת מחדל | ICMP Echo Request | UDP לפורטים גבוהים, החל מ-33434 |
| אפשרויות אחרות | ICMP בלבד | -I לשליחת ICMP, -T לשליחת TCP |
| איך היעד עצמו עונה | Echo Reply | ICMP Port Unreachable, כי פורט ה-UDP הגבוה סגור |
שימו לב שהיעד לעולם לא שולח Time Exceeded: מזהים אותו לפי התשובה האחרת שלו. ושורה של * * * (Request timed out) אומרת רק שמהקפיצה הזו לא חזרה תשובה, בדרך כלל כי הנתב חוסם או מגביל ICMP, ולא בהכרח שהנתיב שבור.
אם קפיצות מאוחרות יותר כן עונות, ברור שהנתב השותק ממשיך להעביר חבילות. ועוד דבר: רוחב פס, חיבורים פעילים, כתובות MAC ופורטים פתוחים לא מופיעים בפלט של traceroute, והוא גם לא מגדיר שום חומת אש.
כך עשוי להיראות פלט של tracert (דוגמה להמחשה, לא הרצה אמיתית):
C:\> tracert files.example.org
1 2 ms 1 ms 1 ms 10.20.0.1
2 7 ms 8 ms 7 ms 172.31.4.1
3 * * * Request timed out.
4 18 ms 17 ms 19 ms 172.31.9.254
5 21 ms 22 ms 21 ms 203.0.113.40למה לא להסתפק ב-ping? ping עונה רק על השאלה אם היעד מגיב ותוך כמה זמן. traceroute מראה את הנתבים שבאמצע, וכך אפשר לאתר באיזו קפיצה בדיוק החיבור נקטע או מתעכב.
Asymmetric Routing: הנתיב מהמקור ליעד והנתיב חזרה לא חייבים להיות אותו נתיב. traceroute רואה רק את כיוון ההלוך, ולכן כדי לבדוק אסימטריה מריצים אותו משני הקצוות, כל צד אל השני, ומשווים את התוצאות.
אותו מספר קפיצות בשני הכיוונים עדיין לא מוכיח שהנתיבים זהים. גם הופעה של הודעות Type 3 אינה סימן לניתוב אסימטרי.
תרחיש 11: שורת כוכביות באמצע הדרך
בפלט שלמעלה קפיצה 3 מציגה * * *, וקפיצה 4 עונה כרגיל.
שאלו את עצמכם איך הבדיקה עם TTL=4 הגיעה לנתב הרביעי. היא חייבת הייתה לעבור דרך הנתב השלישי, כלומר הוא מעביר תעבורה כרגיל ורק את התשובה של עצמו אינו שולח, לרוב בגלל סינון או הגבלה של ICMP. אין אפוא סיבה לחשוד בתקלה אצלו, וגם ברור שהוא לא היעד, כי הדרך נמשכת אחריו.
ועוד לכידה: מישהו שולח ping לשרת רחוק עם TTL נמוך במכוון (ב-Windows ping -i 6), ובתגובה מגיעה הודעת ICMP Type 11 מהכתובת 198.51.100.9. ההודעה אומרת שאצל הנתב הזה ה-TTL הגיע ל-0 והבקשה נזרקה, כך שהשרת עצמו לא ראה אותה בכלל; נתב שאין לו נתיב ליעד היה שולח Type 3 במקומה.
טעויות נפוצות
- ping עובד מעל UDP, או מעל TCP. ping משתמש ב-ICMP, שנארז ישירות ב-IP.
- ping לא ענה, לכן השרת כבוי או שפורט 80 שלו סגור. לא בהכרח. חומת אש שחוסמת ICMP מספיקה, ו-ping בכלל לא בודק פורטים.
- TTL הוא מספר השניות שהחבילה רשאית לשהות ברשת. ב-IP הוא סופר נתבים: כל נתב מוריד 1.
- Type 8 מסמן שגיאה, ובקשת ההד היא Type 3. הפוך: 8 הוא Echo Request, ו-3 הוא Destination Unreachable. וגם Echo Request לא תקוע ברשת המקומית: הוא עובר נתבים כמו כל חבילת IP.
- tracert של Windows שולח UDP, ו-traceroute של Linux שולח ICMP. הפוך: Windows שולח ICMP Echo, ו-Linux שולח UDP כברירת מחדל.
- בכל נתב traceroute משנה את ה-MAC, או שהוא משגר ping מוצפן שה-TTL שלו 255. בכל סבב traceroute מעלה את ה-TTL באחד, ואוסף את הודעות Time Exceeded שחוזרות.
- traceroute רק בודק אם היעד זמין. את זה עושה ping. traceroute מציג את הנתבים שבדרך.
בדקו את עצמכם
תשובת ping מציגה TTL=52. מה המספר הזה אומר?
זה הערך שנותר ב-TTL של חבילת התשובה כשהגיעה אליכם, כלומר ערך ההתחלה של המשיב פחות מספר הנתבים בדרך. אם המשיב התחיל מ-64, כמו Linux, החבילה עברה כ-12 נתבים, וזו הערכה בלבד.
ב-tracert, מי שולח את הודעות Time Exceeded, ואיך יודעים שהגעתם ליעד?
כל נתב בדרך שהוריד את ה-TTL ל-0. היעד עצמו לא שולח Time Exceeded: מזהים אותו לפי Echo Reply, או לפי Port Unreachable ב-traceroute של Linux שעובד עם UDP.
Wireshark: לכידה וניתוח של תעבורה
מה Wireshark עושה, ומה לא
Wireshark לוכד את החבילות שעוברות בכרטיס הרשת ומפרק כל אחת לשכבות, כך שרואים את השדות של כל פרוטוקול, וזה בדיוק מה שצריך כדי לאבחן תקלות. הוא עובד בממשק גרפי, ו-tshark היא הגרסה שלו לשורת הפקודה; הלכידה עצמה נעשית דרך pcap (ב-Windows: Npcap).
קל לייחס ל-Wireshark עבודות של כלים אחרים, ולכן כדאי להעמיד אותו לצדם:
| העבודה | מי עושה אותה |
|---|---|
| חסימת תעבורה | חומת אש |
| חלוקת כתובות IP | DHCP |
| סריקת פורטים | nmap |
| שליחת חבילות מפוברקות לרשת | כלים ייעודיים להזרקה |
| הצפנת התעבורה | פרוטוקולים כמו TLS ו-SSH |
| עצירת ARP Spoofing ותקיפות דומות | מנגנוני הגנה ב-Switch או בחומת האש |
Wireshark עצמו רק מקשיב ומציג. בלכידה שלו אפשר אולי לזהות תקיפה, אבל לא לעצור אותה.
כשהכרטיס עובד במצב Promiscuous, Wireshark מקבל ממנו גם מסגרות שנשלחו לכתובות MAC אחרות. זה לא מביא אליו מסגרות שמלכתחילה לא הגיעו לכבל שלו, כפי שתראו מיד.
חזרה לתוכן הענייניםמסנן לכידה מול מסנן תצוגה
| מסנן לכידה (Capture Filter) | מסנן תצוגה (Display Filter) | |
|---|---|---|
| מתי הוא פועל | מוגדר לפני הלכידה ופועל לאורכה | על חבילות שכבר נלכדו |
| חבילה שלא מתאימה | לא נשמרת בכלל, ואין דרך להחזיר אותה | נעלמת מהמסך אבל נשארת בקובץ |
| תחביר לדוגמה | tcp port 25, host 192.0.2.7 | dns, arp, icmp, ip.addr == 192.0.2.7 |
לכן, אם יש בידיכם קובץ לכידה ענק ואתם רוצים לעבור רק על חבילות ה-DNS בלי לוותר על שום דבר, מקלידים dns בשורת מסנן התצוגה. מסנן לכידה כבר לא חל על לכידה שהסתיימה, וגם אינו יכול למחוק ממנה חבילות.
עוד כמה מסנני תצוגה שימושיים:
http.request.method == "POST"
tcp.flags.ack == 0 && tcp.flags.syn == 1
tcp.flags.reset == 1
tcp.flags.ack == 1 && tcp.flags.syn == 1
tcp.flags.syn == 1- הראשון: רק בקשות HTTP שנשלחו בשיטת POST, למשל הגשות טפסים.
- השני: רק ה-SYN שפותח חיבור, כי ב-SYN-ACK דגל ה-ACK דולק. כך מוצאים מי יזם חיבורים.
- השלישי: חבילות RST, למשל דחיות של פורטים סגורים.
- הרביעי: רק תשובות ה-SYN-ACK של השרתים.
- החמישי: כל חבילה שדגל ה-SYN שלה דולק, כלומר גם ה-SYN של הלקוחות וגם ה-SYN-ACK של השרתים.
Follow TCP Stream הוא כלי מסוג אחר: הוא אוסף את כל החבילות של שיחת TCP אחת ומציג את התוכן שלהן ברצף, כמו תמליל. הוא לא מסנן לפי פרוטוקולים ולא מחבר יחד שיחות שונות.
חזרה לתוכן הענייניםמה מגיע ללוכד, ומה אפשר לקרוא בו
| איפה הלוכד מחובר | מה הוא רואה |
|---|---|
| Hub | הכול, כי כל מסגרת משוכפלת לכל הפורטים |
| Switch | רק את התעבורה של המחשב עצמו, שידורים (Broadcast), Multicast, ומסגרות ליעד שה-Switch עוד לא למד ולכן מציף. כדי לראות יותר צריך Port Mirroring |
| Wi-Fi | כדי לראות תעבורה של לקוחות אחרים צריך מצב Monitor |
וגם כשהחבילה נלכדה, השאלה היא אם אפשר לקרוא אותה:
- פרוטוקולים בטקסט גלוי, כמו Telnet, HTTP ו-IMAP בפורט 143 בלי הצפנה, נקראים במלואם, כולל שמות משתמש וסיסמאות. Follow TCP Stream מציג את כל השיחה.
- ב-SSH וב-HTTPS רואים את הכותרות של השכבות התחתונות, והמטען מוצג כנתונים מוצפנים שלא פוענחו. HTTPS נפתח רק אם מייבאים ל-Wireshark את מפתחות ה-TLS של ההפעלה ומפעילים פענוח: בלי מפתחות אין פענוח, ו-Wireshark גם לא מבקש מפתח פרטי מהשרת.
- גם בתעבורה מוצפנת חלק מהמטא-נתונים נשאר גלוי, למשל מחרוזת הזיהוי שבפתיחת SSH, או שם השרת שהלקוח מבקש ב-TLS.
סימון TCP Retransmission בעמודת Info אומר שמנת נתונים נשלחה שנית, כי האישור עליה לא הגיע בזמן. כשיש הרבה כאלה, סביר שמנות הולכות לאיבוד ברשת.
תרחיש 12: שלוש שאלות על לכידה אחת
צוות תמיכה קיבל קובץ לכידה של כמה עשרות אלפי חבילות. ראשית מבקשים לראות רק את ה-DNS: מחילים dns כמסנן תצוגה, והשאר מוסתר אבל לא נמחק.
אחר כך רוצים לדעת אילו מחשבים יזמו חיבורים: tcp.flags.ack == 0 && tcp.flags.syn == 1 משאיר רק את ה-SYN הפותחים.
ולבסוף, טכנאי מחובר ל-Switch ומצפה לראות את השיחה בין שני מחשבים אחרים, אבל בלכידה שלו אין ממנה זכר. הסיבה היא בדרך שבה ה-Switch עובד ולא בתוכנה: הוא כבר למד באילו פורטים יושבים שני המחשבים ושולח את המסגרות שלהם רק לשם, כך שהן אף פעם לא עוברות בכבל של הטכנאי.
מצב Promiscuous לא יעזור כאן, וגם שום הגדרה אחרת בכרטיס. מה שעובד הוא לבקש מה-Switch עותק של התעבורה (Port Mirroring), או, בסביבת מעבדה, לחבר את שלושתם ל-Hub.
טעויות נפוצות
- Wireshark חוסם תעבורה זדונית, או מחלק כתובות IP. הוא כלי ניתוח בלבד: לוכד ומציג.
- Wireshark יודע לפענח HTTPS גם בלי מפתחות. בלי מפתחות ה-TLS של ההפעלה רואים רק נתונים מוצפנים.
- Wireshark סורק פורטים פתוחים בשרתים. סריקת פורטים היא עבודה של nmap.
- מסנן לכידה שמוחל על לכידה גמורה מוחק ממנה את מה שלא מתאים. מסנן לכידה פועל רק בזמן הלכידה. על קובץ קיים מחילים מסנן תצוגה, והוא רק מסתיר.
- Switch מציף כל מסגרת לכל היציאות, בדיוק כמו Hub. זו התנהגות של Hub. Switch שולח מסגרת מוכרת רק לפורט שלה.
- Switch מצפין את המסגרות או מוריד את ה-TTL שלהן. הוא לא עושה אף אחד מהשניים.
בדקו את עצמכם
איזה מסנן תצוגה ישאיר רק את תשובות ה-SYN-ACK של השרתים?
tcp.flags.ack == 1 && tcp.flags.syn == 1 (הסדר בין שני התנאים לא משנה).
משתמש מתחבר ב-Telnet דרך מנהרת SSH, ואתם לוכדים את התעבורה ברשת. למה לא תמצאו את הסיסמה שלו?
כי בקטע שלכדתם עוברת המנהרה, והיא מוצפנת. רק Telnet רגיל, מחוץ למנהרה, נקרא כטקסט גלוי.
המסע המלא: מכתובת בדפדפן ועד עמוד על המסך
עשרה שלבים שמחברים את כל המושגים
כדי לראות איך עשרים המושגים של הפרק משתלבים זה בזה, נלווה מחשב נייד שזה עתה חובר לרשת ביתית ופותח את http://news.example.org.
| שלב | מה קורה | מושגים |
|---|---|---|
| 1 | למחשב אין עדיין כתובת: הוא משדר Discover לכל הרשת, ובארבעת שלבי DORA מקבל כתובת IP, שער ברירת מחדל וכתובת של שרת DNS | DHCP, Broadcast |
| 2 | בודקים מה התקבל עם ipconfig /all | ipconfig |
| 3 | כדי לשלוח חבילות אל שרת ה-DNS ואל האינטרנט צריך את ה-MAC של השער, ולכן המחשב משדר בקשת ARP, והנתב עונה ישירות אליו | ARP |
| 4 | שאילתה לשרת ה-DNS: מה הכתובת של השם? ב-UDP פורט 53, ומבוקשת רשומת A | DNS |
| 5 | בדרך, ה-Switch מעביר כל מסגרת רק לפורט שלה, וכל נתב מוריד 1 מה-TTL | Switch, TTL |
| 6 | הנתב הביתי מבצע NAT: מחליף את הכתובת הפרטית בכתובת הציבורית שלו ואת פורט המקור בפורט חדש | NAT |
| 7 | הדפדפן קורא ל-connect, ויוצאים SYN, SYN-ACK ו-ACK. בשרת, accept מחזירה Socket חדש לחיבור הזה, כמו לכל לקוח אחר | SYN/ACK, Socket, bind/listen/accept |
| 8 | נשלחת בקשת GET לעמוד, ושליחת טופס תצא ב-POST. האתר עובד ב-HTTP בלבד, ולכן מי שלוכד ב-Wireshark רואה הכול | POST/GET, Wireshark |
| 9 | שרת האתר מוצב ב-DMZ, ובסיס הנתונים שלו נמצא ברשת הפנימית | DMZ |
| 10 | כשמשהו נתקע: ping כדי לבדוק אם היעד מגיב (ICMP), tracert כדי למצוא את הקפיצה שבה זה נעצר, ו-telnet כדי לבדוק אם פורט TCP פתוח | ICMP, Trace, Telnet |
אותו מחשב נייד פוגש גם את שאר המושגים. כשבעלת הבית רוצה לנהל מרחוק את שרת הקבצים הקטן שלה, היא נכנסת ב-SSH, כי ב-Telnet הסיסמה הייתה עוברת ברשת כטקסט קריא; והדואר שלה מוגדר ב-IMAP, כך שהודעה שקראה בנייד מסומנת כנקראה גם בטלפון.
ואם נקודת הגישה האלחוטית והחיבורים החוטיים צריכים להיות רשת אחת עם תחום שידור משותף, Bridge מחבר ביניהם. Hub לא תמצאו בבית כזה: מקומו במעבדה, שם הוא נוח כי כל לוכד שמחובר אליו רואה הכול.
בדקו את עצמכם
בשלב 3, למה המחשב לא מבקש ב-ARP את ה-MAC של שרת האתר עצמו?
כי השרת נמצא ברשת אחרת. בקשת ARP היא שידור, ושידור לא עובר את הנתב, ולכן המחשב מבקש את ה-MAC של השער ושולח אליו.
בשלב 6 הנתב החליף את פורט המקור. האם השרת עדיין יודע להבדיל בין החיבור הזה לחיבורים אחרים?
כן. מבחינת השרת, הכתובת הציבורית והפורט החדש הם צד הלקוח שברביעייה, והנתב זוכר את התרגום ומחזיר כל תשובה למחשב הנכון.
סיכום
לסיום, כל עשרים המושגים של הפרק במבט אחד, ואחריהם הזוגות שהכי קל לבלבל ביניהם.
| מושג | במשפט אחד | מה לזכור |
|---|---|---|
| POST/GET | שתי שיטות של בקשת HTTP | ב-GET הנתונים בכתובת, שאורכה מוגבל, וב-POST בגוף הבקשה. אף אחת מהן לא מצפינה |
| DNS | מתרגם שם לכתובת IP | פורט 53. רשומות A, AAAA, CNAME, MX, NS, PTR. תשובות נשמרות במטמון לפי ה-TTL שלהן |
| SSH | מסוף מרוחק מוצפן | פורט 22. כניסה במפתח או בסיסמה. מפתח המארח נשמר ב-known_hosts |
| Telnet | מסוף מרוחק בלי הצפנה | פורט 23. שימושי גם לבדיקה אם פורט TCP פתוח |
| IMAP | קריאת דואר שנשאר בשרת, עם סנכרון | פורט 143. POP3 מוריד ומוחק מהשרת, SMTP שולח |
| Broadcast | הודעה לכל התחנות ברשת | יעד MAC FF:FF:FF:FF:FF:FF. נתב לא מעביר אותה הלאה |
| ARP | מוצא MAC לפי IP ברשת המקומית | שאלה בשידור, תשובה ישירה. arp -a מציג את הטבלה. אין לו TTL |
| DHCP | מחלק כתובת IP ושאר ההגדרות | DORA, UDP 67/68. כששום שרת לא עונה נשארים עם 169.254.x.x |
| ipconfig | הגדרות הרשת ב-Windows | /all, /release, /renew, /flushdns, /displaydns |
| Hub | שכבה 1, משכפל כל מסגרת לכל הפורטים | תחום התנגשות אחד, Half Duplex |
| Bridge | שכבה 2, לומד כתובות MAC מקור | מפצל תחומי התנגשות אבל לא את תחום השידור. Switch הוא Bridge עם הרבה פורטים |
| NAT | מתרגם כתובות פרטיות לציבורית | PAT מבחין בין חיבורים לפי פורטים. Port Forwarding מאפשר חיבור נכנס |
| DMZ | קטע רשת לשרתים שפונים לאינטרנט | מופרד מהרשת הפנימית. DMZ host בנתב ביתי הוא דבר אחר |
| Socket | נקודת קצה: כתובת IP ופורט | חיבור TCP מזוהה ברביעייה |
| bind/listen/accept | שלבי ההקמה של שרת TCP | bind קובע כתובת ופורט, listen פותח תור, accept מחזיר Socket חדש |
| SYN/ACK | לחיצת היד המשולשת | SYN, SYN-ACK, ACK. בתשובה, Ack גדול ב-1 מה-Seq שנשלח. פורט סגור עונה RST |
| ICMP | הודעות הבקרה והשגיאה של IP | Echo (8 ו-0), Unreachable (3), Time Exceeded (11). אין פורטים |
| TTL | תקרה למספר הנתבים בדרך | כל נתב מוריד 1. ב-DNS זו משמעות אחרת: זמן במטמון |
| Trace | חושף את הנתבים שבדרך | TTL עולה, ומכל נתב חוזר Time Exceeded. * * * אומר רק שלא נענה |
| Wireshark | לכידה וניתוח של תעבורה | מסנן לכידה מול מסנן תצוגה. תוכן מוצפן לא נקרא בלי מפתחות |
כשמבחן מערבב כמה מושגים, בדרך כלל שאלה אחת מכריעה ביניהם:
| המושגים | השאלה שמכריעה | התשובות |
|---|---|---|
| ARP, DNS, DHCP | מה כבר ידוע, ומה מחפשים? | DNS: יש שם מתחם ומחפשים את כתובת ה-IP שלו. ARP: יש כתובת IP ברשת המקומית ומחפשים את ה-MAC שלה. DHCP: אין עדיין כתובת, ומבקשים אחת |
| TTL ב-IP, TTL ב-DNS | איפה השדה יושב? | בכותרת חבילה: מונה נתבים שיורד ב-1. ברשומת DNS: הזמן שבו מותר לשמור את התשובה במטמון |
| ping, traceroute, telnet, Wireshark | מה רוצים לגלות? | אם היעד עונה ל-ICMP: ping. דרך אילו נתבים עוברים: traceroute. אם פורט TCP מסוים מקבל חיבור: telnet. מה בדיוק עבר ברשת: Wireshark |
| IMAP, POP3, SMTP | לאן הדואר זורם? | יוצא אל השרת: SMTP. יורד למכשיר ונמחק מהשרת: POP3. נשאר בשרת ומסונכרן בין מכשירים: IMAP |
| SSH, Telnet | האם מי שבדרך יכול לקרוא? | ב-Telnet כן, הכול גלוי. ב-SSH לא, הערוץ מוצפן. בשניהם מקבלים מסוף מרוחק |
| Hub, Bridge, Switch, נתב | לפי מה מחליטים לאן לשלוח? | Hub לא מחליט ומשכפל (שכבה 1). Bridge לפי MAC (שכבה 2). Switch גם לפי MAC, עם הרבה פורטים ובמהירות (שכבה 2). נתב לפי IP (שכבה 3) |
| NAT, DMZ | מה משתנה? | NAT משנה את הכתובות שבחבילות. DMZ לא משנה דבר בחבילה: הוא מקום מבודד לשרתים ציבוריים |
| bind, listen, accept, connect | מי קורא, ולשם מה? | השרת: bind לכתובת ולפורט, listen לפתיחת התור, accept לקבלת Socket חדש לכל חיבור. הלקוח: connect לפתיחת החיבור |
| ipconfig /release, /renew, /flushdns | מה נמחק או מתחדש? | release מוותר על כתובת ה-IP, renew מבקש כתובת מחדש, flushdns מרוקן את מטמון ה-DNS |
| Broadcast Domain, Collision Domain | על מה הוא מגדיר גבול? | תחום שידור: כל מי ששומע Broadcast. תחום התנגשות: מי שעלול לשדר באותו רגע ולהתנגש |
| מסנן לכידה, מסנן תצוגה | מתי הוא פועל? | לכידה: לפני השמירה, ומה שלא עבר אבד. תצוגה: אחרי הלכידה, ורק מסתיר |
בדקו את עצמכם
מחשב צריך לשלוח חבילה למדפסת ברשת שלו, ולשרת עדכונים באינטרנט, ואינו מכיר את ה-MAC של אף אחד מהם. מה הוא יעשה בכל מקרה?
למדפסת: בקשת ARP בשידור על הכתובת שלה, והיא עונה ישירות. לשרת באינטרנט: המחשב שואל ב-ARP מה ה-MAC של השער (Default Gateway), ושולח את החבילה אליו.
חברה רוצה להעמיד חנות מקוונת שתהיה נגישה מכל מקום באינטרנט. אילו מושגים מהפרק נוגעים לזה?
לכו בדרך של קונה. הדפדפן שלו צריך קודם לתרגם את שם החנות לכתובת, וזו עבודה של DNS. הכתובת צריכה להיות נגישה מבחוץ: לשרת יש כתובת ציבורית משלו, או שהנתב מפנה אליו את החיבורים הנכנסים ב-Port Forwarding של NAT. את השרת מציבים ב-DMZ, הרחק מהרשת הפנימית; שם תוכנת השרת מבצעת bind, listen ו-accept על פורט TCP, ובחיבור שנוצר הדפדפן מבקש עמודים ב-GET ושולח הזמנות ב-POST.