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

Network

Network Infrastructure & Configuration

רכיבי תשתית ותצורת רשת: Hub, Switch, NAT ו-PAT, DHCP, DNS, ARP וכתובות MAC.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

Network Infrastructure & Configuration: איך מחשבים מוצאים זה את זה ומתחברים

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

  • DNS: הפיכת שם כמו catalog.library.org לכתובת IP, דרך שרשרת של שרתים ומטמונים.
  • Broadcast: פנייה לכל התחנות בבת אחת, ואיפה היא נעצרת.
  • ARP: גילוי כתובת ה-MAC שמאחורי כתובת IP ברשת המקומית.
  • DHCP: קבלת כתובת IP ושאר ההגדרות באופן אוטומטי.
  • Hub ו-Bridge: שני רכיבים ותיקים לחיבור תחנות, ובמה הם שונים מ-Switch ומנתב.
  • NAT ו-DMZ: נקודת המפגש בין הרשת הפרטית לבין האינטרנט.
  • ipconfig: הכלי של Windows להצגת ההגדרות שהתקבלו ולשינוי שלהן.
  • TTL: המגבלה על אורך החיים של חבילה, ובנפרד ממנה, של רשומת DNS במטמון.

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

מונחמה הוא
כתובת IPכתובת לוגית שמזהה מחשב ברשת, למשל 10.8.3.17
כתובת MACכתובת פיזית של כרטיס הרשת, שבעזרתה מוסרים מסגרת בתוך הרשת המקומית
נתב (Router)התקן שמעביר תעבורה מרשת אחת לרשת אחרת
שער ברירת מחדל (Default Gateway)הנתב שהמחשב שולח אליו כל דבר שמיועד ליעד מחוץ לרשת שלו
איך הנושאים נקשרים זה בזה: DNS הופך שם לכתובת IP, ARP הופך כתובת IP לכתובת MAC בתוך הרשת המקומית, ו-DHCP נותן למחשב את הכתובת ואת ההגדרות מלכתחילה. ARP ו-DHCP נשענים על Broadcast בדיוק ברגעים שבהם הם עוד לא יודעים למי לפנות.

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

שירות שמות התחום (DNS)

מה DNS עושה, ובאיזה פורט

אנשים נעזרים בשמות, ואילו חבילות ברשת ממוענות לפי מספרים. DNS (Domain Name System) הוא המתווך: שולחים אליו שם מתחם ומקבלים בחזרה כתובת IP, וכך אף אחד לא צריך לשנן כתובות.

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

DNS עובד על פורט 53. שאילתה רגילה נוסעת ב-UDP, כי היא קצרה ומהירה.

יש שני מקרים שבהם עוברים ל-TCP. אם התשובה גדולה ממה שנכנס ב-UDP, השרת שולח אותה קטועה ומסמן אותה truncated, והלקוח שולח את אותה שאילתה מחדש ב-TCP. גם zone transfer, העתקה של כל הרשומות של תחום משרת DNS אחד לאחר, מתבצעת ב-TCP.

מצבפרוטוקול
שאילתה ותשובה רגילותUDP, פורט 53
תשובה שסומנה truncatedהלקוח חוזר על השאילתה ב-TCP, פורט 53
zone transfer בין שרתיםTCP, פורט 53

השרתים מסודרים בהיררכיה של שלוש רמות:

  • Root: הקודקוד. השרתים האלה יודעים אילו שרתים אחראים על כל סיומת.
  • TLD (Top-Level Domain): שרתים לכל סיומת, למשל org, com או il.
  • Authoritative (סמכותי): השרת שבו יושבות בפועל הרשומות של דומיין מסוים.
חזרה לתוכן העניינים

סוגי הרשומות

כל פיסת מידע ב-DNS שמורה כרשומה (Record), ולכל סוג רשומה משמעות משלו. ששת הסוגים שחשוב להכיר:

סוגמה הרשומה אומרתדוגמה
Aשם שמצביע על כתובת IPv4catalog.library.org אל 172.20.5.40
AAAAשם שמצביע על כתובת IPv6catalog.library.org אל 2001:db8::40
CNAMEשם חלופי שמפנה לשם אחר, ואת הכתובת מחפשים אצל השם האחרbooks.library.org מפנה ל-catalog.library.org
MXאיזה שרת מקבל את הדואר הנכנס של הדומייןהדואר של library.org נמסר ל-mail.library.org
NSאיזה שרת שמות אחראי על התחום, או על תת-תחום שלוlibrary.org מנוהל בשרת ns1.library.org
PTRהכיוון ההפוך: כתובת IP שמצביעה על שם (Reverse DNS)172.20.5.40 אל catalog.library.org

שני צמדים שכדאי לזכור: משם לכתובת זו רשומת A (או AAAA ב-IPv6), ומכתובת לשם זו רשומת PTR. רשומת MX עוסקת רק בשאלה לאיזה שרת נמסר הדואר הנכנס, ואין לה שום קשר למספרי פורטים.

חזרה לתוכן העניינים

שרשרת הפתרון: Resolver, Root, TLD ו-Authoritative

הדפדפן ומערכת ההפעלה לא יוצאים בעצמם למסע בין שרתי העולם. הם מוסרים את השאלה לשרת אחד, ה-DNS Resolver, ומחכים לתשובה מוגמרת.

ה-Resolver הוא שרת DNS מסוג Recursive שהלקוח הוגדר לעבוד מולו, לרוב של ספק האינטרנט או של שירות DNS ציבורי. הלקוח, מערכת ההפעלה או הנתב הביתי שמתווך בשבילה, רק מעביר את השאלה הלאה. את העבודה עצמה עושה ה-Resolver.

ה-Resolver מתחיל במטמון (Cache) שלו. אם השם לא נמצא שם, הוא יוצא לסבב של שאילתות איטרטיביות, שבו כל שרת עונה רק במה שהוא יודע:

  1. שרת Root לא מכיר את כתובת האתר. הוא מסתכל על הסיומת ועונה בהפניה: אלה שרתי ה-TLD שאחראים עליה.
  2. שרת ה-TLD של הסיומת גם הוא לא מחזיק את הכתובת. הוא מפנה לשרת ה-Authoritative של הדומיין.
  3. שרת ה-Authoritative מחזיק את הרשומות המקוריות, ומחזיר את הכתובת עצמה.
  4. ה-Resolver שומר את התשובה במטמון ומוסר אותה ללקוח.

הסימולציה הבאה בונה Resolver זעיר: שלושה מילונים ממלאים את תפקידי ה-Root, ה-TLD וה-Authoritative, ומילון רביעי משמש מטמון שהתוקף שלו נקבע לפי TTL. הלקוח שואל על אותו שם בארבעה רגעים שונים:

Python
# A toy resolver: iterative walk from root to TLD to authoritative, with a TTL cache
ROOT = {"org": "tld-org"}                        # root only knows who runs each TLD
TLD = {"tld-org": {"library.org": "auth-library"}}  # TLD only knows the authoritative server
AUTH = {"auth-library": {"catalog.library.org": ("172.20.5.40", 300)}}  # real records live here

cache = {}   # name -> (address, expires_at)

def resolve(name, now):
    if name in cache and cache[name][1] > now:
        print(f"t={now}: {name} answered from cache")
        return cache[name][0]
    suffix = name.rsplit(".", 1)[1]
    tld = ROOT[suffix]
    print(f"t={now}: root refers to {tld}")
    domain = ".".join(name.split(".")[-2:])
    auth = TLD[tld][domain]
    print(f"t={now}: {tld} refers to {auth}")
    address, ttl = AUTH[auth][name]
    print(f"t={now}: {auth} answers {address} (TTL {ttl})")
    cache[name] = (address, now + ttl)
    return address

for t in (0, 120, 299, 301):
    print("client got", resolve("catalog.library.org", t))
פלט
t=0: root refers to tld-org
t=0: tld-org refers to auth-library
t=0: auth-library answers 172.20.5.40 (TTL 300)
client got 172.20.5.40
t=120: catalog.library.org answered from cache
client got 172.20.5.40
t=299: catalog.library.org answered from cache
client got 172.20.5.40
t=301: root refers to tld-org
t=301: tld-org refers to auth-library
t=301: auth-library answers 172.20.5.40 (TTL 300)
client got 172.20.5.40

בשאילתה הראשונה רואים את שתי ההפניות ואת התשובה הסופית. בשניות 120 ו-299 התשובה מגיעה ישר מהמטמון, בלי לפנות לאף שרת. בשנייה 301 כבר עברו יותר מ-300 שניות, הרשומה פקעה, והסבב המלא מתחיל מחדש.

רכיבתפקידומה הוא לא עושה
Resolverמריץ את כל סבב השאילתות בשביל הלקוח ושומר תשובות במטמוןאינו המקור של רשומות הדומיין
Rootמפנה לשרתי ה-TLD של הסיומתאינו יודע את כתובת האתר ואינו מחזיר ללקוח תשובה סופית
TLDמפנה לשרת ה-Authoritative של הדומייןאינו מחזיק את הרשומות של האתרים
Authoritativeמחזיק את הרשומות המקוריות ומשיב עליהן בעצמו, בתשובה מוסמכתאינו שואל Resolver אחר כדי לאשר את מה שהוא עונה

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

שרתי ה-Root לא שומרים תשובות בשביל אף לקוח: את המטמון מחזיק ה-Resolver. ומי שנותן ללקוח כתובת IP ואת כתובות שרתי ה-DNS ברגע שהוא מתחבר לרשת הוא DHCP, לא DNS.
טעויות נפוצות
  • שרת Root שולח ללקוח את כתובת האתר. Root עונה רק בהפניה לשרתי ה-TLD של הסיומת. הכתובת עצמה מגיעה מה-Authoritative, ואל הלקוח היא מגיעה דרך ה-Resolver.
  • ה-Resolver הוא המקור של רשומות הדומיין, וה-Authoritative הוא זה ששומר תשובות במטמון. ההפך. ה-Resolver שואל ושומר במטמון; ה-Authoritative מחזיק את הרשומות ועונה עליהן.
  • ה-Resolver ושרת ה-Root הם אותו שרת, וה-Authoritative הוא שמריץ את החיפוש בשביל הלקוח. אלה שלושה תפקידים נפרדים. ה-Resolver פונה אל ה-Root כמו אל כל שרת אחר בשרשרת, וה-Authoritative רק עונה על השאלה שמגיעה אליו.
  • DNS מנתב חבילות, או מנטר וחוסם תעבורה. DNS רק מתרגם שמות לכתובות. ניתוב, ניטור וסינון שייכים לרכיבים אחרים.
  • DNS מחלק כתובות IP למחשבים שמתחברים לרשת. זו העבודה של DHCP. DNS לא נותן כתובת לאף מחשב, הוא רק עונה מה הכתובת של שם.
חזרה לתוכן העניינים

מטמון ו-TTL של רשומה

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

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

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

מכאן ההמלצה לשירותים שחייבים להיות זמינים: אם ייתכן שיעברו לשרת גיבוי (Failover) או שהכתובת הציבורית שלהם תתחלף, נותנים לרשומה שלהם TTL נמוך. המחיר הוא יותר שאילתות.

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

חזרה לתוכן העניינים

קובץ hosts, ומה nslookup רואה

לפני שמערכת ההפעלה פונה ל-DNS, היא מציצה בקובץ טקסט מקומי בשם hosts, שבו אפשר לקבוע ידנית איזו כתובת שייכת לאיזה שם. ב-Windows מקומו C:\Windows\System32\drivers\etc\hosts.

כל תוכנה שמבקשת ממערכת ההפעלה לתרגם שם, כמו ping או הדפדפן, מושפעת מהקובץ: אם יש בו שורה לשם, הכתובת נלקחת ממנו ואין פנייה לשרת DNS. ב-Linux סדר הבדיקה כתוב בקובץ /etc/nsswitch.conf, בשורה files dns, כלומר קודם הקבצים ואחר כך DNS.

nslookup ו-dig הם כלי אבחון של DNS, ולכן הם עוקפים את מנגנון התרגום המקומי. הם שולחים את השאילתה ישר לשרת ה-DNS, ואת קובץ hosts הם בכלל לא קוראים.

Text
# line added to the hosts file of one PC
172.20.9.99   catalog.library.org

ping catalog.library.org       uses 172.20.9.99              (hosts is consulted first)
nslookup catalog.library.org   shows the DNS server's answer (hosts is never read)

ההשפעה של הקובץ מקומית לגמרי. הוא לא משנה דבר בשרת ה-DNS, ושאר המחשבים ברשת ממשיכים לקבל את הכתובת הרגילה.

טעויות נפוצות
  • nslookup בודק קודם את קובץ hosts. nslookup פונה ישר לשרת ה-DNS. מי שקורא את hosts הוא מנגנון התרגום של מערכת ההפעלה, שבו משתמשים ping והדפדפן.
  • קובץ hosts הוא גיבוי שנבדק רק כששרת ה-DNS לא עונה. הסדר הפוך: הקובץ נבדק ראשון, ואם יש בו שורה מתאימה, לא פונים לשרת בכלל.
  • שורה שנוספה ל-hosts מתעדכנת גם בשרת ה-DNS, וכל הרשת תגיע לכתובת החדשה. הקובץ קיים רק במחשב שבו ערכו אותו. השרת והמחשבים האחרים לא יודעים עליו.
חזרה לתוכן העניינים

Split DNS, האצלה ו-Reverse DNS

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

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

השרת החיצוני חושף כלפי חוץ רק את מה שציבורי, כמו שרתי ה-DMZ. התוצאה: מי שבחוץ לא לומד איך בנויה הרשת הפנימית, והרשומות הפנימיות בכלל לא נמצאות בשרת החיצוני.

האצלה (Delegation): בתחום האב מוסיפים רשומות NS שמעבירות תת-תחום, נניח public.library.org, לשרת שמות נפרד. מאותו רגע השרת הזה הוא הסמכותי על החלק הזה, ושאילתות מבחוץ על שירותי ה-DMZ מגיעות אליו ונענות על ידו ישירות.

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

Reverse DNS: רשומת PTR עונה על השאלה ההפוכה, איזה שם שייך לכתובת IP. שרת דואר שמקבל הודעה יכול להיעזר בה כדי לבדוק אם הכתובת של השרת ששלח אותה מתאימה לשם מתחם מוכר.

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

חזרה לתוכן העניינים

הגדרת שרת DNS ב-Windows, ו-DNS Spoofing

את שרת ה-DNS קובעים ידנית בהגדרות של כרטיס הרשת: פותחים את Internet Protocol Version 4 (TCP/IPv4), לוחצים Properties, וממלאים את כתובות השרתים בשדות של DNS.

מה עושיםהאם זה קובע שרת DNS?
כתובת בשדות ה-DNS בהגדרות TCP/IPv4כן, זו הדרך
שורה בקובץ hostsלא: הקובץ מצמיד שמות מסוימים לכתובות, אבל אינו בוחר שרת
כתובת בשדה Default Gatewayלא: השדה הזה מיועד לנתב
ipconfig /flushdnsלא: הפקודה מרוקנת את המטמון המקומי ולא בוחרת שרת

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

בדקו את עצמכם
ה-Resolver מקבל שאלה על שם שאינו מכיר ושאינו במטמון שלו. אל מי הוא פונה קודם, ומה יחזור אליו?

אל שרת Root. הוא לא יקבל ממנו כתובת אלא הפניה לשרתי ה-TLD שאחראים על הסיומת.

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

MX לדואר, PTR לכיוון מכתובת לשם.

מנהל רשם ב-hosts כתובת פרטית לשם של אתר ציבורי. מה יראה ping לשם הזה, ומה יראה nslookup?

ping יפנה לכתובת הפרטית מהקובץ. nslookup יראה את תשובת שרת ה-DNS, כי הוא פונה לשרת ישירות.

שרת DNS צריך להחזיר תשובה גדולה מכדי להיכנס ב-UDP. מה יקרה?

השרת ישלח תשובה מסומנת truncated, והלקוח יחזור על השאילתה ב-TCP, גם הפעם בפורט 53.

חזרה לתוכן העניינים

תרחישים: DNS בפעולה

תרחיש 1: שאילתה שעוברת את כל השרשרת

מחשב במשרד שואל על portal.harbor.net, וה-Resolver של הספק לא נתקל בשם הזה מעולם.

  1. המחשב שולח את השאלה ל-Resolver ומחכה.
  2. ה-Resolver פונה לשרת Root ומקבל הפניה: לשאול את שרתי ה-TLD של net.
  3. שרת ה-TLD של net עונה בהפניה נוספת, לשרת ה-Authoritative של harbor.net.
  4. ה-Authoritative מחזיר רשומת A עם הכתובת.
  5. ה-Resolver שומר את הרשומה למשך ה-TTL שלה ומוסר את הכתובת למחשב.

מחשב שני ששואל על אותו שם דקה אחר כך מקבל תשובה מהמטמון של ה-Resolver, ואף שרת בשרשרת לא נשאל שוב.

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

לרשומה של אתר חנות יש TTL של 86400 שניות, כלומר יממה שלמה, והחברה עוברת לשרת עם כתובת IP אחרת.

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

כל עוד ה-TTL נמוך, שרתי ה-DNS של החברה מקבלים הרבה יותר שאילתות. זה המחיר של עדכון מהיר.

תרחיש 3: שורה ב-hosts של מחשב אחד

איש תמיכה מוסיף ב-hosts של המחשב שלו שורה שמצמידה את wiki.lab לכתובת 10.50.0.20.

  • במחשב שלו: הדפדפן ו-ping מגיעים ל-10.50.0.20, ואילו nslookup מראה את התשובה של שרת ה-DNS.
  • במחשבים אחרים ברשת: שום דבר לא השתנה, כי שרת ה-DNS לא יודע על הקובץ.
תרחיש 4: Split DNS בארגון עם DMZ

לארגון יש אתר שרץ על שרת ב-DMZ, ושרת דוחות פנימי בשם reports.

  • השרת החיצוני מכיר רק את הרשומה של האתר, שמצביעה על השרת ב-DMZ.
  • הרשומה של reports קיימת רק בשרת הפנימי, ועובדים מבפנים מקבלים אותה ממנו.
  • מישהו מהאינטרנט שואל על reports ולא מקבל כתובת, כי בשרת החיצוני אין רשומה כזו.
חזרה לתוכן העניינים

שידור (Broadcast)

Broadcast מול Unicast ו-Multicast

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

שלושה אופני שליחה שקל לבלבל ביניהם:

אופןהנמעניםדימוי
Unicastתחנה אחת מסוימתשיחת טלפון לאדם אחד
Multicastרק התחנות שנרשמו מראש לקבוצהרשימת תפוצה שמקבלים ממנה רק מי שנרשמו
Broadcastכל התחנות ברשת המקומיתכריזה ברמקול במסדרון
חזרה לתוכן העניינים

לאן ממענים Broadcast

כתובת השידור תלויה בשכבה שבה מסתכלים על ההודעה:

  • בשכבת הקישור (Ethernet), המסגרת ממוענת ל-FF:FF:FF:FF:FF:FF, כתובת MAC שכל הביטים שלה דלוקים.
  • ברמת IP יש שתי אפשרויות. 255.255.255.255 היא ה-Broadcast המוגבל, שמשמעותו 'כל מי שנמצא איתי ברשת המקומית'. האפשרות השנייה היא כתובת השידור של רשת מסוימת, הכתובת האחרונה בטווח שלה, למשל 10.8.3.255 ברשת 10.8.3.0/24.

את הכתובת האחרונה של רשת אפשר לחשב בעזרת המודול ipaddress של Python:

Python
import ipaddress

# directed broadcast: the last address of each network
for net in ("10.8.3.0/24", "172.31.64.0/20", "192.168.50.0/26"):
    n = ipaddress.ip_network(net)
    print(f"{net:<17} broadcast {n.broadcast_address}")

# limited broadcast: same value on every network, never routed
print("limited broadcast", ipaddress.ip_address("255.255.255.255"))
פלט
10.8.3.0/24       broadcast 10.8.3.255
172.31.64.0/20    broadcast 172.31.79.255
192.168.50.0/26   broadcast 192.168.50.63
limited broadcast 255.255.255.255

כתובת השידור של כל רשת נגזרת מהמסכה שלה: ברשת /20 היא נופלת על 172.31.79.255, וברשת /26 על 192.168.50.63. רק 255.255.255.255 זהה בכל רשת.

ARP לא עוטף את עצמו בחבילת IP: ההודעה יושבת ישר בתוך מסגרת Ethernet. לכן בבקשת ARP ה-Broadcast מתבטא רק בכתובת ה-MAC FF:FF:FF:FF:FF:FF, ואין בה כתובת IP של שידור.
חזרה לתוכן העניינים

תחום שידור: עד איפה Broadcast מגיע

תחום שידור (Broadcast Domain) הוא אוסף כל התחנות ש-Broadcast אחד מגיע אליהן. הגבול שלו נקבע לפי ההתקנים שבדרך.

התקןמה הוא עושה עם Broadcast
Hubמשכפל אותו לכל היציאות
Bridgeמציף אותו לכל הצדדים
Switchמציף אותו לכל הפורטים
נתבלא מעביר אותו לרשת אחרת, ולכן תחום השידור מסתיים בו

ברירת המחדל של נתב היא לא להעביר Broadcast מרשת לרשת. הוא גם לא שומר את ההודעה עד שמישהו יבקש אותה, ולא בוחר רשת אחת שאליה ישלח אותה.

החריג המוכר הוא DHCP Relay: נתב שהוגדר כך מעביר הודעת DHCP של לקוח לשרת שנמצא ברשת אחרת. גם אז ה-Broadcast עצמו לא חוצה את הנתב, אלא הנתב שולח במקומו הודעת Unicast לשרת, כפי שנראה בחלק על DHCP.

חזרה לתוכן העניינים

מי שולח Broadcast, ולמה הרבה ממנו מכביד

שני פרוטוקולים מרכזיים פונים לכולם כדי לגלות משהו או לקבל משהו:

  • ARP: מחפש את כתובת ה-MAC שמאחורי כתובת IP.
  • DHCP: הלקוח שולח Discover כדי לאתר שרת DHCP כלשהו.

HTTP, FTP, SSH, TLS ו-SNMP לא בנויים על Broadcast לגילוי או להקצאה: הם פונים לשרת שהכתובת שלו כבר ידועה.

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

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

עוד שתי תכונות: אין ל-Broadcast אישור קבלה, ואין בו הצפנה.

טעויות נפוצות
  • נתב מפיץ Broadcast לכל הרשתות שמחוברות אליו. נתב עוצר Broadcast. ההודעה מגיעה רק לרשת שבה נשלחה.
  • Broadcast ממוען לשער ברירת המחדל, ומשם הוא מחולק לתחנות. ההודעה ממוענת לכתובת שידור ונקלטת ישירות בכל התחנות. השער אינו מתווך, וגם הוא לא מעביר אותה הלאה.
  • Broadcast ו-Multicast הם אותו דבר, או ש-Broadcast מגיע לתחנה אחת. Multicast מגיע רק למי שהצטרף לקבוצה, Unicast לתחנה אחת, ו-Broadcast לכל הרשת המקומית.
  • בקשת ARP הולכת רק לנתב. היא ממוענת לכתובת השידור, וכל מי שמחובר לרשת המקומית קולט אותה.
  • חיבור התחנות ל-Hub מקטין את תחום השידור. Hub משכפל הכול לכולם. רק נתב מפצל את הרשת לתחומי שידור נפרדים.
בדקו את עצמכם
לאיזו כתובת MAC ממוענת מסגרת שידור?

FF:FF:FF:FF:FF:FF.

נתב מחבר ארבע רשתות, ותחנה ברשת השלישית שולחת Broadcast. מי יקבל אותו?

רק התחנות ברשת השלישית. הנתב אינו מעביר את ההודעה לשלוש הרשתות האחרות.

מה כתובת השידור של הרשת 10.8.3.0/24, ובמה היא שונה מ-255.255.255.255?

10.8.3.255, הכתובת האחרונה בטווח, ששייכת לרשת הזו בלבד. 255.255.255.255 היא ה-Broadcast המוגבל, ומשמעותה זהה בכל רשת: כל התחנות ברשת המקומית.

חזרה לתוכן העניינים

תרחישים: Broadcast בפעולה

תרחיש 5: מי שומע את ההודעה

שלוש רשתות, X, Y ו-Z, מחוברות לנתב אחד. ברשת X חמש תחנות מחוברות ל-Hub, ואחת מהן שולחת Broadcast.

  • ה-Hub משכפל את ההודעה לארבע התחנות האחרות ברשת X.
  • הנתב לא מעביר אותה לרשת Y ולא לרשת Z.
  • התוצאה: כל התחנות ב-X קיבלו את ההודעה, ואף תחנה ב-Y או ב-Z לא קיבלה אותה.
תרחיש 6: רשת אחת שגדלה יותר מדי

במפעל יש רשת שטוחה אחת עם 600 תחנות, ובשעות הבוקר היא מוצפת בבקשות ARP ובהודעות DHCP Discover. כל אחת מ-600 התחנות מעבדת כל אחת מההודעות האלה.

  • מחלקים את הרשת לשלושה קטעים בעזרת נתב, 200 תחנות בכל קטע.
  • מעכשיו כל Broadcast מגיע ל-200 תחנות בלבד.
  • אם שרת DHCP אחד ממשיך לשרת את כל הקטעים, מגדירים בנתב DHCP Relay, כי ה-Discover כבר לא חוצה אותו בעצמו.
חזרה לתוכן העניינים

פרוטוקול ARP

הבעיה ש-ARP פותר

תחנה שרוצה לשלוח חבילה לתחנה שכנה כבר מכירה את ה-IP של היעד. אבל ברשת המקומית כרטיס הרשת שולח מסגרת (Frame), ומסגרת ממוענת לכתובת MAC, כך שחסר הקשר בין השתיים.

ARP (Address Resolution Protocol) סוגר את הפער: בהינתן כתובת IP, הוא מגלה את כתובת ה-MAC שמאחוריה. הכיוון ההפוך, מ-MAC ל-IP, אינו התפקיד שלו.

ARP גם לא מחלק כתובות IP, שזה תפקיד של DHCP, ולא קובע באיזה נתיב חבילות יעברו, שזה תפקיד של נתב.

ARP חי רק בתוך הרשת המקומית. כשהיעד נמצא ברשת אחרת, החבילה צריכה לצאת דרך שער ברירת המחדל, ולכן התחנה מבצעת ARP על הכתובת של השער ומקבלת את ה-MAC שלו.

הודעת ARP אינה חבילת IP. היא יושבת ישירות בתוך מסגרת Ethernet, עם EtherType 0x0806, ולכן אין לה כותרת IP וגם אין לה TTL.

חזרה לתוכן העניינים

בקשה ותשובה

  1. הבקשה (ARP Request): התחנה שואלת 'למי שייכת 10.1.1.7?' ושולחת את השאלה ב-Broadcast, לכתובת FF:FF:FF:FF:FF:FF. כל התחנות ברשת המקומית קולטות אותה.
  2. התשובה (ARP Reply): רק התחנה שהכתובת 10.1.1.7 שלה עונה, ב-Unicast ישירות לשואלת: 'הכתובת הזו אצלי, וזה ה-MAC שלי'.
  3. השואלת רושמת את הצמד בטבלת ה-ARP שלה ושולחת את המסגרת.

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

Text
request (broadcast, to ff-ff-ff-ff-ff-ff): who has 10.1.1.7 ? tell 10.1.1.30
reply   (unicast, to 10.1.1.30)          : 10.1.1.7 is at 0c-0c-0c-00-00-07
חזרה לתוכן העניינים

טבלת ה-ARP: רשומות דינמיות, סטטיות ופקיעה

טבלת ה-ARP היא מטמון. בלעדיה התחנה הייתה צריכה לשאול מחדש לפני כל חבילה.

ב-Windows מציגים אותה בפקודה arp -a. לכל ממשק מוצגת רשימה בשלוש עמודות: Internet Address (כתובת ה-IP), Physical Address (כתובת ה-MAC) ו-Type, שבה כתוב dynamic או static.

פעולהפקודההערה
הצגת הטבלהarp -aכל הממשקים והרשומות שלהם
הוספת רשומה סטטיתarp -s 10.1.1.250 0c-0c-0c-00-00-faמוגדרת ידנית ואינה פוקעת
מחיקת רשומה אחתarp -d 10.1.1.7בשימוש הבא תישלח בקשה חדשה
מחיקת כל הרשומותarp -d *הטבלה תתמלא מחדש לפי הצורך

רשומה דינמית (dynamic) נלמדת מהרשת, מחזיקה זמן מוגבל ונמחקת אם אינה מתרעננת. רשומה סטטית (static) נשארת עד שמוחקים אותה.

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

Python
# A toy ARP cache: dynamic entries age out, static ones never do,
# and any reply is accepted as is (ARP has no authentication)
AGE = 60
cache = {}   # ip -> [mac, kind, learned_at]

def on_reply(ip, mac, now):
    if ip in cache and cache[ip][1] == "static":
        return                                   # static entries are not overwritten
    cache[ip] = [mac, "dynamic", now]            # whoever answered is believed

def show(now):
    for ip in list(cache):
        mac, kind, t = cache[ip]
        if kind == "dynamic" and now - t > AGE:
            del cache[ip]                        # aged out: next use needs a new request
    print(f"t={now}")
    for ip, (mac, kind, _) in cache.items():
        print(f"  {ip:<12} {mac}  {kind}")

cache["10.1.1.250"] = ["0c-0c-0c-00-00-fa", "static", 0]   # like arp -s
on_reply("10.1.1.1", "0c-0c-0c-00-00-01", 0)                # the real gateway answers
on_reply("10.1.1.7", "0c-0c-0c-00-00-07", 10)               # a file server
show(20)
on_reply("10.1.1.1", "0e-ee-ee-ee-ee-66", 30)               # unsolicited fake reply
show(40)
show(95)
פלט
t=20
  10.1.1.250   0c-0c-0c-00-00-fa  static
  10.1.1.1     0c-0c-0c-00-00-01  dynamic
  10.1.1.7     0c-0c-0c-00-00-07  dynamic
t=40
  10.1.1.250   0c-0c-0c-00-00-fa  static
  10.1.1.1     0e-ee-ee-ee-ee-66  dynamic
  10.1.1.7     0c-0c-0c-00-00-07  dynamic
t=95
  10.1.1.250   0c-0c-0c-00-00-fa  static

בשנייה 40 ה-MAC של השער 10.1.1.1 כבר הוחלף בכתובת שהגיעה בתשובה הלא מבוקשת, בלי שום בדיקה. בשנייה 95 שתי הרשומות הדינמיות כבר עברו את 60 השניות ונמחקו, והרשומה הסטטית נשארה.

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

הרשומה מתעדכנת כשאותו מחשב שולח הודעת ARP שנושאת את ה-MAC החדש. אם הודעה כזו לא מגיעה, הרשומה מזדקנת ונמחקת, והתחנה תשאל שוב ב-Broadcast בפעם הבאה שתצטרך את הכתובת.

אף רכיב חיצוני לא מתקן את הטבלה בשבילכם: שרת DNS מתרגם שמות לכתובות IP, שרת DHCP מחלק כתובות IP, והנתב אינו שולח עדכוני ARP יזומים. ו-ARP גם לא מחזיק שתי רשומות לאותה כתובת IP כדי לחלק עומס.

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

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

חזרה לתוכן העניינים

ARP Spoofing

ב-ARP אין אימות מכל סוג. כל תחנה רשאית לשלוח תשובת ARP, ותחנות שמקבלות אותה רושמות אותה בטבלה בלי לשאול שאלות, בדיוק כמו בסימולציה למעלה.

תוקף ברשת המקומית מנצל את זה ושולח תשובות כוזבות שמצמידות כתובת IP של מישהו אחר, לרוב של השער, ל-MAC שלו. התעבורה שהייתה אמורה לצאת לשער מגיעה אליו, והוא יכול לקרוא אותה ולהעביר אותה הלאה: man-in-the-middle.

הסבר שמציעים למתקפהנכון?
ARP לא מאמת מי שלח את התשובהכן, זו הסיבה
ל-ARP יש הצפנה שקל לפרוץלא: ב-ARP אין הצפנה בכלל
ARP עובר מעל TCP ואפשר לחטוף את החיבורלא: ARP נישא ישירות בתוך Ethernet
בקשות ARP נשלחות ב-Unicast לנתבלא: בקשות ARP נשלחות ב-Broadcast
חזרה לתוכן העניינים

Gratuitous ARP ו-Proxy ARP

Gratuitous ARP היא הודעה שבה תחנה מכריזה מיוזמתה איזה MAC שייך לכתובת ה-IP שלה, בלי שמישהו שאל. היא שימושית כשה-MAC התחלף, או כשמכונה וירטואלית עברה למארח אחר וכולם צריכים לעדכן את הטבלה.

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

הודעת Gratuitous ARP לא נוגעת בכתובת ה-IP של השולחת, אינה קשורה לחכירות DHCP, ואינה יוצאת דרך הנתב לרשתות אחרות, כי נתב לא מעביר Broadcast.

Proxy ARP: התקן, בדרך כלל נתב או חומת אש, עונה על בקשת ARP שנוגעת לכתובת IP של התקן אחר, כלומר עונה במקומו. ב-ARP הרגיל עונה רק בעל הכתובת עצמו.

גם Proxy ARP שייך לעולם IPv4. הוא לא מחלק כתובות ואין לו שום קשר ל-DNS.

טעויות נפוצות
  • ARP מתרגם MAC לכתובת IP. הכיוון הוא מ-IP ל-MAC: התחנה יודעת את כתובת ה-IP ומחפשת את ה-MAC.
  • המיפוי בין IP ל-MAC שמור בשרת ה-DNS או בשרת ה-DHCP. הוא שמור בטבלת ה-ARP של כל תחנה. DNS ממפה שמות ל-IP, ו-DHCP מחלק כתובות IP.
  • בקשת ARP עוברת דרך נתבים לרשתות אחרות. הבקשה היא Broadcast, ונתב לא מעביר Broadcast. ליעד מרוחק מבצעים ARP לשער בלבד.
  • להודעת ARP יש כותרת IP, ולכן גם TTL. ARP נישא ישירות במסגרת Ethernet. אין כותרת IP ואין TTL.
  • רשומה דינמית נשארת עד שמוחקים אותה, ורשומה סטטית מתבטלת אחרי זמן. ההפך: הדינמית פוקעת לבד, הסטטית נשארת עד מחיקה ידנית.
  • ARP מוצפן, או לפחות מאמת את השולח. אין בו לא הצפנה ולא אימות, ולכן ARP Spoofing אפשרי.
בדקו את עצמכם
התחנה 10.1.1.30 שולחת חבילה לכתובת 1.1.1.1 שבאינטרנט. על איזו כתובת IP תבוצע בקשת ה-ARP?

על הכתובת של שער ברירת המחדל. היעד אינו ברשת המקומית, ולכן המסגרת ממוענת ל-MAC של השער.

באיזו פקודה רואים את טבלת ה-ARP ב-Windows, ובאיזו מרוקנים אותה כולה?

arp -a להצגה, arp -d * למחיקת כל הרשומות.

בהקלטת תעבורה אתם מסתכלים על הודעת ARP ומחפשים בה את ערך ה-TTL. מה תמצאו?

לא תמצאו TTL בכלל. ההודעה יושבת ישר במסגרת Ethernet, בלי כותרת IP, ושדה TTL קיים רק בכותרת כזו.

למה Gratuitous ARP שנשלח ברשת אחת לא מעמיס על רשת אחרת שמחוברת אליה דרך נתב?

כי ההודעה יוצאת ב-Broadcast, והנתב לא מעביר Broadcast.

חזרה לתוכן העניינים

תרחישים: ARP בפעולה

תרחיש 7: שליחה לשכנה ברשת

התחנה P (10.1.1.30) רוצה לשלוח לתחנה Q (10.1.1.7), ואין לה רשומה עבורה.

  1. P שולחת ב-Broadcast: 'למי שייכת 10.1.1.7?'.
  2. כל התחנות קולטות, ורק Q עונה ב-Unicast עם ה-MAC שלה.
  3. P רושמת רשומה דינמית ושולחת את המסגרת ל-MAC של Q.
  4. בחבילה הבאה ל-Q אין צורך לשאול: הצמד נמצא במטמון.
תרחיש 8: שליחה לשרת באינטרנט

P רוצה לשלוח חבילה לשרת מרוחק.

  • P בודקת ומגלה שהיעד אינו ברשת שלה, ולכן מבצעת ARP לכתובת של שער ברירת המחדל.
  • בחבילה, כתובת ה-IP של היעד נשארת כתובת השרת המרוחק, אבל כתובת ה-MAC במסגרת היא של השער.
  • השער מקבל את המסגרת וממשיך להעביר את החבילה.
תרחיש 9: כרטיס רשת חדש, טבלה ישנה

בשרת 10.1.1.7 הוחלף כרטיס הרשת. כתובת ה-IP לא השתנתה, אבל ה-MAC חדש.

  • בטבלה של P עדיין רשום ה-MAC הישן, והמסגרות ש-P שולחת לא מגיעות לשרת.
  • אפשרות אחת: לחכות שהרשומה הדינמית תפקע.
  • אפשרות שנייה: למחוק אותה ב-arp -d 10.1.1.7, וכך הבקשה הבאה תלמד את ה-MAC החדש.
  • אפשרות שלישית: השרת שולח הודעת ARP, למשל Gratuitous ARP, עם ה-MAC החדש.
תרחיש 10: התחזות לשער

תחנה זדונית מציפה את הרשת בתשובות ARP: '10.1.1.1, השער, נמצא ב-MAC שלי'.

  • התחנות רושמות את המיפוי הכוזב, כי אין שום אימות.
  • כל מה שהן שולחות לאינטרנט מגיע קודם לתוקף, שיושב באמצע (man-in-the-middle).
חזרה לתוכן העניינים

הקצאת כתובות אוטומטית (DHCP)

למה צריך DHCP

מחשב שמצטרף לרשת צריך ארבעה פרטים כדי לעבוד: כתובת IP ומסכת רשת (Subnet Mask), הכתובת של שער ברירת המחדל, וכתובות של שרתי DNS. אפשר להקליד אותם ידנית בכל מחשב, וזו הקצאה סטטית.

DHCP (Dynamic Host Configuration Protocol) עושה זאת אוטומטית. שרת DHCP מעניק ללקוח כתובת IP, מסכה, שער ושרתי DNS, ובנוסף זמן חכירה (Lease) שקובע לכמה זמן הכתובת שלו.

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

מה עושיםמי עושה את זה
חלוקת כתובת IP והגדרות רשת ללקוחותDHCP
תרגום כתובות פרטיות לכתובת ציבוריתNAT
תרגום שמות לכתובות IPDNS
החזקת המיפוי בין IP ל-MACARP
חלוקת הרשת לקבוצות שידור נפרדותVLAN
חזרה לתוכן העניינים

ארבעת השלבים: DORA

DHCP רץ מעל UDP: השרת מאזין בפורט 67, והלקוח בפורט 68. בתחילת התהליך אין ללקוח כתובת, ולכן הוא פונה ב-Broadcast.

שלבהשולחתוכן
Discoverהלקוחשידור לכולם מכתובת המקור 0.0.0.0: האם יש כאן שרת DHCP?
Offerהשרתהצעה: כתובת IP וההגדרות שמתלוות אליה
Requestהלקוחהלקוח מודיע שהוא לוקח את הכתובת שהוצעה ומציין מאיזה שרת. בהקצאה הראשונה גם השלב הזה יוצא ב-Broadcast
Acknowledgeהשרתאישור סופי: הכתובת שייכת עכשיו ללקוח

דרך קלה לזכור: הצדדים מתחלפים. הלקוח פותח (Discover), השרת מציע (Offer), הלקוח מבקש (Request), השרת מאשר (Acknowledge).

DHCP Release אינו אחד מארבעת השלבים. זו הודעה שהלקוח שולח כשהוא מחזיר את הכתובת לשרת.

Text
client 0.0.0.0:68 -> 255.255.255.255:67  DISCOVER
server :67        -> client :68           OFFER    10.30.4.61/24, gateway 10.30.4.1, dns 10.30.0.53
client 0.0.0.0:68 -> 255.255.255.255:67  REQUEST  10.30.4.61, chosen server 10.30.0.5
server :67        -> client :68           ACK      lease 8 hours
חזרה לתוכן העניינים

חכירה וחידוש

כתובת מ-DHCP אינה ניתנת לתמיד. היא מושכרת לזמן מוגדר, זמן החכירה (Lease Time), והלקוח מחדש אותה לפני שהזמן אוזל.

החידוש לא דורש Broadcast: הלקוח כבר יודע מי השרת, ופונה אליו ישירות ב-Unicast.

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

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

חזרה לתוכן העניינים

בלי שרת: כתובת APIPA

כרטיס שמוגדר לקבל כתובת ב-DHCP שולח Discover. אם אף Offer לא חוזר, כי השרת כבוי או לא נגיש, Windows מקצה לכרטיס בעצמו כתובת מהטווח 169.254.x.x.

זו כתובת APIPA (Automatic Private IP Addressing). המסכה שלה 255.255.0.0, ושדה ה-Default Gateway נשאר ריק, כי היא מיועדת רק לתקשורת בתוך הרשת המקומית.

שורה בפלט של ipconfigמה מופיע בה כשהתקבלה APIPA
Autoconfiguration IPv4 Addressכתובת בטווח 169.254.x.x
Default Gatewayריק
Subnet Mask255.255.0.0

גם macOS ומערכות Linux רבות נעזרות באותו טווח Link-Local. בעזרת ipaddress אפשר לראות איך Python מסווג כתובת APIPA לעומת Loopback וכתובת פרטית רגילה:

Python
import ipaddress

for text in ("169.254.88.3", "127.0.0.1", "192.168.7.20"):
    a = ipaddress.ip_address(text)
    print(f"{text:<14} link-local={a.is_link_local!s:<5} loopback={a.is_loopback}")

apipa = ipaddress.ip_network("169.254.0.0/16")
print("APIPA mask:", apipa.netmask)
פלט
169.254.88.3   link-local=True  loopback=False
127.0.0.1      link-local=False loopback=True
192.168.7.20   link-local=False loopback=False
APIPA mask: 255.255.0.0

רק כתובת ה-APIPA מסווגת link-local, ואילו 127.0.0.1 מסווגת loopback, דבר אחר לגמרי. והמסכה של הטווח 169.254.0.0/16 היא אכן 255.255.0.0.

מה כתובת APIPA אינה:

  • היא לא הגיעה משרת DHCP: שרת DHCP לא מחלק כתובות 169.254.
  • NAT לא יצר אותה.
  • היא לא כתובת Loopback, שהיא 127.0.0.1.
  • היא לא תוצאה של תשובת ARP.
  • היא גם לא שארית: אחרי ipconfig /release הכרטיס לא ממשיך להציג את הכתובת מההקצאה הקודמת.
חזרה לתוכן העניינים

DHCP Relay ו-Helper Address

ה-Discover הוא Broadcast, ונתב לא מעביר Broadcast. כשהשרת נמצא מעבר לנתב, ברשת שאינה הרשת של הלקוחות, ה-Discover נעצר בדרך והשרת לא שומע עליו.

כאן נכנס DHCP Relay Agent, שמוגדר על נתב או על Switch מסוג Layer 3. הוא קולט את השידור של הלקוח ושולח את התוכן ב-Unicast לשרת ה-DHCP שברשת האחרת. בציוד של Cisco ההגדרה נקראת Helper Address, או IP Helper.

התוצאה: שרת DHCP מרכזי אחד מספיק לכמה רשתות או VLAN, ואין צורך בשרת נפרד בכל אחת. כשהשרת והלקוחות באותה רשת, אין שום צורך ב-Relay.

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

מה מייחסים ל-Relayלמה זה לא שלו
הארכת חכירותאת זמן החכירה קובע שרת ה-DHCP, והלקוח מחדש אותה מול השרת
תרגום כתובותזו העבודה של NAT
הצפנת הודעות DHCPה-Relay לא מצפין דבר: הוא רק שולח את הבקשה לשרת כ-Unicast במקום כשידור
ניתוב חיבורי TCP או חסימת SSHאלה עניינים של ניתוב רגיל ושל חומת אש, ולא של רכיב שמטפל בהודעות DHCP
חזרה לתוכן העניינים

אופציות, שני שרתים, ושרת מתחזה

אופציות (Options): מעבר לכתובת, למסכה, לשער ול-DNS, שרת DHCP יכול לצרף להצעה פרטים נוספים. שתי אופציות מוסרות ללקוח נתיבים סטטיים כבר בהקצאה: Option 121, ששמה Classless Static Route, והוותיקה ממנה, Option 33, ששמה Static Route. כך לא צריך להגדיר אותם ידנית בכל תחנה.

נתיבים לא מגיעים ללקוח בהודעת Discover, לא ברשומת A של DNS, ולא בבקשת ARP: הם מגיעים מהשרת, כאופציות.

שני שרתים בלי תיאום: ב-DHCP אין מנגנון מובנה שמתאם בין שרתים. כל אחד מהם עלול להציע כתובת שהשני כבר נתן, ושני מחשבים יחזיקו את אותה כתובת IP, יתנגשו ויאבדו תקשורת.

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

שרת מתחזה (Rogue DHCP): שרת שלא הוסמך עונה ללקוחות ומחלק להם כתובת, שער ושרתי DNS שהוא בחר, למשל כדי להעביר את התעבורה דרכו.

ההגנה היא DHCP Snooping, תכונה של ה-Switch שמבחינה בהודעות DHCP. היא מתירה תשובות DHCP רק מפורטים שסומנו Trusted, אלה שאליהם מחובר השרת הלגיטימי, וחוסמת תשובות כאלה מכל פורט אחר.

טענה על DHCP Snoopingמה נכון
הוא מחלק כתובות IPv6 לתחנות חדשותהוא לא מחלק שום כתובת. הוא רק מסנן תשובות DHCP לפי הפורט שממנו הגיעו
הוא מעדיף את התעבורה של הנתביםתעדוף תעבורה אינו חלק ממנו. הוא בודק רק הודעות DHCP
אחריו כבר לא צריך VLAN נפרד ל-DMZהפרדת רשתות היא עניין אחר, ו-Snooping לא מחליף אותה
טעויות נפוצות
  • DHCP הופך כתובות פרטיות לכתובת ציבורית, או שמות לכתובות. הראשון הוא NAT והשני DNS. DHCP מחלק כתובות והגדרות.
  • ה-Request נשלח מהשרת וה-Offer מהלקוח. הלקוח שולח Discover ו-Request, השרת שולח Offer ו-Acknowledge.
  • כתובת 169.254.x.x נשלחה מהשרת או מהנתב. המחשב נתן אותה לעצמו, דווקא משום שאף שרת לא ענה.
  • חכירה ארוכה מקטינה התנגשויות ומצמידה לכל מכשיר כתובת קבועה. היא רק משאירה כתובות תפוסות זמן רב, גם אצל מכשירים שכבר לא ברשת, וכך המאגר מתרוקן.
  • הנתב מעביר מעצמו את ה-Discover לשרת שברשת אחרת. בלי Relay הוא עוצר אותו. רק Relay מעביר, וגם הוא שולח Unicast ולא מעביר את השידור.
  • שני שרתי DHCP שאינם מתואמים חוסמים זה את זה, והלקוחות נשארים בלי כתובת. שניהם ממשיכים לחלק, והסכנה היא כתובת אחת אצל שני מחשבים.
בדקו את עצמכם
מאיזו כתובת מקור יוצא ה-Discover, ולמה דווקא ממנה?

מ-0.0.0.0, כי עדיין אין ללקוח כתובת משלו.

פלט של ipconfig מראה 169.254.88.3, מסכה 255.255.0.0 ושער ריק. מה קרה?

המחשב לא קיבל Offer משום שרת DHCP, ונתן לעצמו כתובת APIPA. הוא יכול לתקשר רק בתוך הרשת המקומית.

שרת DHCP יחיד יושב ברשת השרתים, והלקוחות בשתי רשתות אחרות מעבר לנתב. מה מגדירים, ואיפה?

DHCP Relay (Helper Address), על הנתב או על Switch מסוג Layer 3. הרכיב הזה תופס את השידור של הלקוחות ושולח את ההודעה לשרת ב-Unicast.

איך לקוח יכול לקבל נתיבים סטטיים בלי שמישהו יגדיר אותם בתחנה?

השרת שולח אותם כאופציות DHCP, למשל Option 121, יחד עם הכתובת והמסכה.

חזרה לתוכן העניינים

תרחישים: DHCP בפעולה

תרחיש 11: מחשב חדש מקבל כתובת

מחשב נייד מתחבר לרשת של משרד, בלי כתובת.

  1. Discover: שידור מכתובת 0.0.0.0, מפורט 68 לפורט 67.
  2. Offer: השרת מציע 10.30.4.61, עם מסכה, שער ושרת DNS.
  3. Request: הלקוח לוקח את ההצעה ומציין את השרת שהציע אותה.
  4. Acknowledge: השרת מאשר, ומכאן נספר זמן החכירה.

המחשב עובד עם 10.30.4.61, ולפני שהחכירה תיגמר הוא יחדש אותה ב-Unicast מול אותו שרת.

תרחיש 12: השרת לא עונה

שרת ה-DHCP של מעבדה נפל בלילה, ובבוקר מחברים לרשת מחשב חדש.

  • המחשב שולח Discover ולא מקבל Offer.
  • Windows נותן לכרטיס 169.254.88.3, מסכה 255.255.0.0, ובלי שער.
  • המחשב יכול לדבר רק עם הרשת המקומית, ואין לו יציאה לאינטרנט.
  • כשהשרת חוזר לפעול, מריצים ipconfig /renew והמחשב מקבל כתובת תקינה.
תרחיש 13: שרת אחד, ארבע רשתות

בקמפוס ארבע רשתות מחוברות בנתב, ושרת DHCP יחיד יושב ברשת השרתים.

  • בלי Relay, כל Discover מרשתות התחנות נעצר בנתב, והשרת לא שומע עליו.
  • מגדירים Helper Address על ממשקי הנתב שפונים לרשתות התחנות.
  • מעכשיו הנתב שולח את הבקשות ב-Unicast לשרת, ושרת אחד מחלק כתובות לכל הרשתות.
תרחיש 14: נתב ביתי ברשת המשרד

עובד מחבר לשקע במשרד נתב ביתי ששרת ה-DHCP שלו פעיל.

  • חלק מהמחשבים מקבלים ממנו את ההצעה הראשונה, ואיתה שער ושרת DNS לא נכונים.
  • הפתרון: להפעיל DHCP Snooping ב-Switch, לסמן Trusted רק את הפורט של השרת הלגיטימי, ולחסום תשובות DHCP מכל פורט אחר.
חזרה לתוכן העניינים

Hub ו-Bridge

Hub: מה שנכנס יוצא בכל מקום

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

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

  • אין לו טבלת MAC, והוא לא לומד כתובות.
  • כל תחנה מקבלת את כל התעבורה, גם את מה שלא מיועד לה, והרשת נעמסת בלי צורך.
  • האזנה (sniffing) קלה מאוד, כי כל תחנה רואה הכול.
  • כל התחנות נמצאות בתחום התנגשות (Collision Domain) אחד, חולקות רוחב פס אחד, ועובדות בחצי דופלקס (Half Duplex).

כל מה ש-Hub לא עושה נובע מאותה סיבה: הוא לא קורא כתובות ולא שומר מצב. לכן:

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

Bridge: לומד, מסנן ומעביר לפי MAC

Bridge (גשר) מחבר שני מקטעים (Segments) של רשת. הוא פועל בשכבה 2, שכבת הקישור, ומחליט לפי כתובות MAC. כתובות IP הן עניין של נתב.

הגשר עושה ארבעה דברים עם מסגרות:

פעולהמתימה קורה
לימודבכל מסגרת שמגיעההגשר רושם את MAC המקור ואת הצד שממנו המסגרת הגיעה
העברההיעד ידוע ונמצא בצד השניהמסגרת עוברת רק לצד שבו היעד נלמד
סינוןהיעד ידוע ונמצא באותו צד של השולחהמסגרת לא עוברת לצד השני
הצפה (flooding)Broadcast, Multicast או יעד שעוד לא נלמדהמסגרת נשלחת לכל הצדדים

הסימולציה הבאה בונה גשר עם שני צדדים: D1 ו-D2 בצד 1, ו-E5 בצד 2. הטבלה מתחילה ריקה, ובכל מסגרת רואים את ההחלטה:

Python
# A two-sided learning bridge: learn the source, then filter, forward or flood
BROADCAST = "ff:ff:ff:ff:ff:ff"
table = {}   # mac -> side

def frame(src, dst, side):
    table[src] = side                            # learn where the sender lives
    if dst == BROADCAST or dst not in table:
        action = "flood to every other side"
    elif table[dst] == side:
        action = "filter (stays on this side)"
    else:
        action = f"forward to side {table[dst]} only"
    print(f"{src[-2:]} -> {dst[-2:]} from side {side}: {action}")

frame("02:00:00:00:00:d1", "02:00:00:00:00:d2", 1)   # D1 to D2, D2 unknown yet
frame("02:00:00:00:00:d2", "02:00:00:00:00:d1", 1)   # D2 answers on the same side
frame("02:00:00:00:00:d1", "02:00:00:00:00:d2", 1)   # both known on side 1
frame("02:00:00:00:00:e5", "02:00:00:00:00:d1", 2)   # E5 lives on side 2
frame("02:00:00:00:00:d2", "02:00:00:00:00:e5", 1)   # now E5 is known
frame("02:00:00:00:00:d1", BROADCAST, 1)
print("table:", {m[-2:]: s for m, s in table.items()})
פלט
d1 -> d2 from side 1: flood to every other side
d2 -> d1 from side 1: filter (stays on this side)
d1 -> d2 from side 1: filter (stays on this side)
e5 -> d1 from side 2: forward to side 1 only
d2 -> e5 from side 1: forward to side 2 only
d1 -> ff from side 1: flood to every other side
table: {'d1': 1, 'd2': 1, 'e5': 2}

המסגרת הראשונה הוצפה כי D2 עוד לא היה בטבלה. מהרגע ש-D2 ענה, תעבורה בין D1 ל-D2 נשארת בצד 1, ומסגרת ל-E5 עוברת רק לצד 2. ה-Broadcast בשורה האחרונה הוצף למרות שהטבלה כבר מלאה.

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

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

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

מתי לבחור גשר ולא נתב? כששני המקטעים צריכים להישאר רשת לוגית אחת ורוצים להגדיל אותה בלי ניתוב. לחבר רשתות נפרדות, להחליט לפי כתובות IP ולנהל כתובות בשכבה 3 יודע רק נתב.

חזרה לתוכן העניינים

Hub, Bridge, Switch ונתב זה לצד זה

התקןשכבהעל מה מבוססת ההחלטהתחום התנגשותתחום שידורמקטין TTL
Hub1אין החלטה: הכול לכולםאחד, משותף לכל התחנותאחד, Broadcast עוברלא
Bridge2MAC של היעדנפרד לכל צדאחד, Broadcast עוברלא
Switch2MAC של היעדנפרד לכל פורטאחד, Broadcast עוברלא
נתב3IP של היעדנפרד לכל ממשקנעצר בנתבכן

Switch הוא למעשה Bridge עם הרבה יציאות, שמבצע את ההעברה בחומרה. מה שמבדיל ביניהם הוא רק מספר היציאות והמהירות.

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

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

טעויות נפוצות
  • Hub לומד כתובות MAC ושולח רק ליציאה של היעד. זה מה ש-Switch עושה. Hub לא מסתכל בכתובות בכלל ומשדר לכל היציאות.
  • ב-Hub קשה להאזין לתעבורה של אחרים. ההפך: כל תחנה מקבלת את כל התעבורה, ולכן האזנה קלה במיוחד.
  • Hub עובד בדופלקס מלא, ו-Switch בחצי דופלקס. הפוך. ב-Hub כל התחנות חולקות ערוץ אחד בחצי דופלקס.
  • גשר מחליט לפי כתובות IP. החלטה לפי IP היא של נתב. גשר עובד בשכבה 2, לפי MAC.
  • גשר מעביר כל מסגרת לכל הצדדים. הוא מציף רק Broadcast, Multicast ומסגרות ליעד שלא נלמד. כל השאר מועבר לצד הנכון או מסונן.
  • גשר מוריד את ה-TTL ב-1 או מצפין את המסגרות. גשר לא נוגע בכותרת IP ולא מצפין. רק נתב מקטין TTL.
  • גשר מגביר אות שנחלש בכבל ארוך. זו העבודה של Repeater. הגשר מחליט לפי כתובות, ולא משחזר אותות.
בדקו את עצמכם
באיזו שכבה של OSI עובד Hub, ובאיזו Bridge?

Hub בשכבה 1, הפיזית. Bridge בשכבה 2, שכבת הקישור.

לגשר מגיעה מסגרת ל-MAC שאינו בטבלה שלו. מה הוא יעשה, ומה ישתנה כשהיעד יענה?

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

גשר מחלק רשת לשני מקטעים. האם יש עכשיו שני תחומי שידור?

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

ב-Switch, האם תחנה יכולה לקבל מסגרת שלא נועדה לה?

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

חזרה לתוכן העניינים

תרחישים: Hub ו-Bridge בפעולה

תרחיש 15: הגשר לומד תוך כדי עבודה

לגשר שני צדדים. בצד 1 התחנות K ו-L, בצד 2 התחנה M, והטבלה ריקה.

  1. K שולחת ל-L. הגשר רושם ש-K בצד 1. את L הוא עוד לא מכיר, ולכן המסגרת מוצפת גם לצד 2.
  2. L עונה ל-K. הגשר רושם ש-L בצד 1. היעד K כבר ידוע כמי שנמצא בצד 1, והמסגרת הגיעה מצד 1, לכן היא לא עוברת לצד 2.
  3. K שולחת שוב ל-L. שתיהן בצד 1, הגשר מסנן, ו-M לא רואה כלום.
תרחיש 16: אותה שיחה דרך Hub

K, L ו-M מחוברות הפעם ל-Hub.

  • כש-K שולחת ל-L, ה-Hub משדר את האות ל-L, ל-M ולכל יציאה אחרת.
  • M מקבלת את כל השיחה בין K ל-L, ויכולה להאזין לה.
תרחיש 17: להגדיל רשת, או להוסיף רשת

מעבדה רוצה לחבר עוד חדר עם כבלים לרשת הקיימת 10.60.0.0/24, בלי לשנות אף כתובת IP.

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

תרגום כתובות (NAT)

למה צריך NAT ומה הוא עושה

כתובות IPv4 ציבוריות הן מצרך נדיר, ואי אפשר להקצות אחת לכל טלפון, מדפסת ומחשב נייד. לכן בתוך בתים וארגונים עובדים עם כתובות פרטיות, משלושה טווחים ששמורים לכך: 10.0.0.0/8, 172.16.0.0/12 ו-192.168.0.0/16. נתבים באינטרנט לא מעבירים חבילות שממוענות לטווחים האלה.

NAT (Network Address Translation) הוא הגשר בין שני העולמות. הנתב שבקצה הרשת מחליף, בכל חבילה שיוצאת החוצה, את כתובת המקור הפרטית בכתובת הציבורית שלו, ולתרגום הזה של כתובת המקור קוראים Source NAT.

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

חזרה לתוכן העניינים

שלושה סוגים: Static NAT, Dynamic NAT ו-PAT

סוגמה קורה בתרגוםמתי בוחרים בו
Static NAT (1:1)כל כתובת פנימית קשורה לכתובת ציבורית משלה, והקשר לא משתנה. אין כאן חיסכון: כל כתובת פנימית שממפים צורכת כתובת ציבורית שלמהשרת שחייב כתובת חיצונית שלא זזה
Dynamic NATלנתב יש מאגר (Pool) של כתובות ציבוריות. תחנה שיוצאת החוצה מקבלת כתובת שאינה בשימוש כרגע, לזמן מוגבלארגון שבידיו כמה כתובות ציבוריות
PAT (NAT Overload)כתובת ציבורית אחת (או קומץ כתובות) משרתת את כל התחנות, ומה שמבדיל בין החיבורים הוא מספר הפורטכמעט כל נתב ביתי. כשאומרים "NAT" בשיחה רגילה, בדרך כלל מתכוונים לזה
PAT אינו שם נוסף ל-NAT אלא אחד מסוגיו: NAT שמתרגם גם את הפורט ולא רק את הכתובת. ומה אם כל מכשיר מקבל כתובת ציבורית משלו מתוך מאגר? זה Dynamic NAT, לא PAT.

ההבחנה שהכי הרבה נבחנים עליה: Static NAT הוא זוג קבוע של כתובת פנימית וכתובת חיצונית. ב-PAT, לעומת זאת, כתובות פנימיות רבות יושבות על כתובת חיצונית אחת, וכל חיבור מקבל פורט משלו.

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

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

Python
# A toy PAT router: many inside hosts share one public address
PUBLIC_IP = "198.51.100.7"
table = {}            # public port -> (inside ip, inside port)
next_port = 61000

def outbound(src_ip, src_port):
    global next_port
    pub_port = next_port
    next_port += 1
    table[pub_port] = (src_ip, src_port)   # remember who opened this connection
    return (PUBLIC_IP, pub_port)

def inbound(dst_port):
    return table.get(dst_port, "no entry, dropped")

print(outbound("10.0.0.21", 49152))
print(outbound("10.0.0.22", 49152))   # same inside port, different host
print(inbound(61001))                  # reply to the second connection
print(inbound(8080))                   # unsolicited packet from the internet
פלט
('198.51.100.7', 61000)
('198.51.100.7', 61001)
('10.0.0.22', 49152)
no entry, dropped

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

כתובת ופורט בפניםכתובת ופורט בחוץ, אחרי התרגום
10.0.0.21 : 49152198.51.100.7 : 61000
10.0.0.22 : 49152198.51.100.7 : 61001

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

חזרה לתוכן העניינים

חיבורים שמגיעים מבחוץ: Port Forwarding

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

כשרוצים ששרת בתוך הרשת יקבל חיבורים מבחוץ, כותבים בנתב כלל Port Forwarding: פורט מסוים בכתובת הציבורית ממופה באופן קבוע אל מכונה מסוימת ברשת, בכתובת ובפורט שלה. הכלל מתרגם את כתובת היעד של חבילה נכנסת, ולכן הוא דוגמה ל-DNAT (Destination NAT).

Python
# Inbound traffic: only a rule written by the admin creates a mapping
forward_rules = {}    # public port -> (inside ip, inside port)

def inbound(dst_port):
    return forward_rules.get(dst_port, "no entry, dropped")

print("before:", inbound(443))
forward_rules[443] = ("10.0.0.50", 443)   # Port Forwarding rule
print("after: ", inbound(443))
print("other: ", inbound(22))             # still closed
פלט
before: no entry, dropped
after:  ('10.0.0.50', 443)
other:  no entry, dropped

כלל אחד פותח פורט אחד בלבד: פורט 22 נשאר סגור, כי אף כלל לא נכתב עבורו.

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

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

מה NAT נותן ומה רק נדמה שהוא נותן

היכולתהאם NAT מספק אותה?
חיסכון בכתובות ציבוריות: מחשבים רבים, כתובת אחתכן
הסתרת הכתובות הפנימיות וחסימת גישה ישירה מבחוץ לתחנה מסוימתכן: לתחנה אין כתובת ציבורית משלה, ולתעבורה נכנסת שלא התבקשה אין רשומה
תוספת כתובות ציבוריות לארגוןלא: המצאי נשאר כשהיה, רק מנוצל טוב יותר
הצפנת התעבורהלא: הצפנה היא התפקיד של VPN, TLS או IPsec
חומת אשלא מטבעו
חלוקת כתובות לתחנות או מתן שרתי DNSלא: זה עניינם של DHCP ו-DNS

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

טעויות נפוצות
  • NAT פותח את המחשבים בפנים לגישה ישירה מהאינטרנט. המצב הפוך: בלי רשומה בטבלה או כלל מפורש, תעבורה שמגיעה מבחוץ נעצרת בנתב.
  • NAT מצפין את מה שיוצא מהרשת. הוא רק מחליף כתובות, וב-PAT גם פורטים. את ההצפנה עושים VPN, TLS או IPsec.
  • Dynamic NAT הוא המיפוי הקבוע, ו-Static NAT בוחר כתובת מהמאגר. הפוך. Static הוא זוג קבוע 1:1, ו-Dynamic בוחר בכל פעם כתובת פנויה מהמאגר.
  • ב-PAT כל תחנה מקבלת כתובת ציבורית משלה, כמו במיפוי 1:1. PAT מושיב תחנות רבות על כתובת אחת ומבדיל ביניהן בפורטים. כתובת נפרדת לכל מכשיר מתוך מאגר היא Dynamic NAT.
  • PAT ו-NAT הם שתי מילים לאותו דבר. PAT הוא תת-סוג של NAT, שמוסיף תרגום של פורטים.
  • מספיק שלשרת תהיה כתובת פרטית קבועה כדי שיגיעו אליו מבחוץ. כתובת קבועה לא יוצרת רשומת תרגום. צריך כלל Port Forwarding בנתב.
  • הנתב מחליף את כתובות ה-MAC כחלק מה-NAT. NAT עובד על כתובות IP ועל פורטים. כתובות MAC בכלל לא יוצאות מגבולות הרשת המקומית.
בדקו את עצמכם
חנות מקוונת רוצה ששם הדומיין שלה יצביע תמיד על אותה כתובת חיצונית של השרת. באיזה סוג NAT תשתמשו?

Static NAT, שנותן לשרת כתובת חיצונית קבועה.

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

לפי הפורט החיצוני שהוא הקצה לכל חיבור.

הפעלתם שרת SSH במחשב בבית ואתם רוצים להתחבר אליו מבחוץ בפורט 22. מה מגדירים בנתב?

כלל Port Forwarding שממפה את פורט 22 בכתובת הציבורית לכתובת הפנימית של המחשב, לפורט 22 שלו.

חזרה לתוכן העניינים

תרחישים: NAT בפעולה

תרחיש 18: שתי תחנות מול אותו אתר

התחנות 10.0.0.21 ו-10.0.0.22 פותחות חיבור לאותו אתר חדשות, דרך נתב שהכתובת הציבורית שלו 198.51.100.7.

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

תשובה שחוזרת לפורט 61001 מגיעה לנתב, הוא מוצא בטבלה את 10.0.0.22 ומוסר לה את החבילה.

תרחיש 19: מצלמת אבטחה שרוצים לראות מבחוץ

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

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

תרחיש 20: מאגר של ארבע כתובות

לארגון ארבע כתובות ציבוריות, והנתב מפעיל Dynamic NAT. תחנה שיוצאת לאינטרנט מקבלת אחת מהן מהמאגר, לזמן מוגבל.

למחרת אותה תחנה עשויה לקבל כתובת אחרת. לכן אי אפשר לפרסם עבורה רשומת DNS קבועה: מי שצריך כתובת חיצונית יציבה צריך Static NAT.

חזרה לתוכן העניינים

אזור מפורז (DMZ)

למה מפרידים את השרתים הציבוריים

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

DMZ (Demilitarized Zone) הוא מקטע רשת נפרד שנמצא בין האינטרנט לבין הרשת הפנימית, ובו מציבים את השרתים הציבוריים. חוקי חומת אש מפרידים בינו לבין הרשת הפנימית, ולכן תוקף שהשתלט על שרת ב-DMZ נתקע שם: הדרך שלו פנימה מוגבלת.

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

הרבה טעויות נובעות מכך שמייחסים ל-DMZ יכולות שאין לו. הנה מה שהוא לא עושה:

  • הוא לא מסתיר את כתובות ה-IP של השרתים בפנים.
  • הוא לא מערכת ניטור ולא שולח התרעות על מה שקורה ברשת הפנימית.
  • הוא לא מצפין דבר ולא בונה מנהרת VPN.
  • הוא לא מאיץ גלישה, לא מזרז תעבורה בין מחלקות ולא נותן לשרת רוחב פס נפרד.
  • הוא לא תחליף לנתב הראשי ולא רשת לגיבויים.
  • הוא לא מחלק כתובות IP: זה התפקיד של DHCP.
  • הוא לא רשת סגורה שבה העובדים עובדים בשקט: הוא בדיוק החלק של הרשת שפתוח כלפי חוץ.
חזרה לתוכן העניינים

שני מבנים: שתי חומות אש או חומה אחת עם שלושה ממשקים

  • שתי חומות אש בטור: החיצונית יושבת בין האינטרנט ל-DMZ, והפנימית בין ה-DMZ לרשת הפנימית. ה-DMZ הוא המרווח שביניהן.
  • חומת אש אחת עם שלושה ממשקים (Multi-homed): ממשק אחד פונה לאינטרנט, אחד לרשת הפנימית ואחד מוקדש ל-DMZ.

המילה home כאן פירושה ממשק רשת. חומת אש Multi-homed היא אפוא חומה עם כמה ממשקים, שכל אחד מהם מחובר לרשת אחרת: החיצונית, הפנימית וה-DMZ.

היתרון של המבנה הזה: ל-DMZ יש ממשק משלו, וכל חבילה שעוברת בין שתי רשתות, לכל כיוון, חייבת לעבור דרך החוקים של חומת האש.

לחומת אש Single-homed יש חיבור רשת יחיד. כל התעבורה נכנסת ויוצאת דרכו, וההפרדה תלויה ברכיבים נוספים ברשת, ולכן זו דרך פחות מומלצת לבנות DMZ.

מבנהכמה חומות אשאיך ה-DMZ מחובר
שתי חומות אששתייםבמרווח שבין החיצונית לפנימית
Multi-homedאחתעל ממשק ייעודי משלו
Single-homedאחת, עם ממשק יחידבלי ממשק נפרד; ההפרדה נשענת על רכיבים אחרים, ולכן פחות מומלץ
Multi-homed לא פירושו שתי חומות אש. שתי חומות עם DMZ ביניהן הן המבנה השני, ו-Multi-homed הוא חומה אחת עם כמה ממשקים.
חזרה לתוכן העניינים

חוקי חומת האש, וכלל ה-NAT שמכניס את הלקוחות

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

  • מהאינטרנט אל השרת: להתיר רק את פורט השירות הציבורי, למשל 443 לאתר מאובטח.
  • מהשרת אל הרשת הפנימית: לחסום חיבורים שהשרת ב-DMZ יוזם לכיוון הפנים.

וכך נראות הגדרות שמחטיאות את המטרה:

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

עוד דבר נחוץ: לרוב השרת ב-DMZ מקבל כתובת פרטית, ופנייה מהאינטרנט לא תמצא אותו לבד. בנתב מגדירים כלל NAT מסוג Port Forwarding, שלוקח פנייה לכתובת הציבורית בפורט מסוים ומעביר אותה לכתובת הפנימית של השרת.

לצד הכלל הזה מוסיפים בדרך כלל חוק בחומת האש שמתיר את השירות הזה בלבד.

שלושה דברים שלא עוזרים כאן, אף שהם נשמעים קשורים:

  • רשומת ARP סטטית: היא מצמידה IP ל-MAC רק בתוך הרשת המקומית, ולא מכניסה תעבורה מבחוץ.
  • טווח DHCP נפרד ל-DMZ: הוא נותן לשרת כתובת פרטית, וכתובת פרטית לא נגישה מהאינטרנט.
  • ערך TTL גבוה יותר: הוא קובע כמה נתבים חבילה רשאית לעבור, לא מי רשאי להגיע לשרת.
חזרה לתוכן העניינים

DMZ host בנתב ביתי: אותו שם, דבר אחר

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

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

ומה לא קורה? ההפניה מתבצעת בתוך ה-NAT של הנתב. השרת ממשיך לענות ללקוחות שלו, ושאר המחשבים בבית גולשים בדיוק כמו קודם, בלי שהחבילות שלהם יעברו דרכו.

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

DNS, דואר ו-SNAT לשרתי ה-DMZ

  • TTL נמוך ברשומות ה-DNS של שרתי ה-DMZ: כשמחליפים כתובת, למשל במעבר לשרת גיבוי, השינוי מגיע ללקוחות מהר. מדובר ב-TTL של רשומת DNS ולא בשדה TTL שבכותרת IP, וההבדל מוסבר בפרק על TTL.
  • Split DNS: שרת ה-DNS החיצוני מפרסם רק את הרשומות הציבוריות של ה-DMZ (פירוט בפרק על DNS).
  • האצלה (Delegation): תת-תחום ששייך ל-DMZ עובר לסמכות של שרת שמות ייעודי, בעזרת רשומות NS (גם זה בפרק על DNS).
  • Reverse DNS לשרת הדואר: רשומת PTR, שמתרגמת כתובת IP בחזרה לשם, על הכתובת הציבורית של שרת הדואר ב-DMZ מאפשרת לשרת שמקבל את ההודעה לאמת את השולח.

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

הפתרון הוא SNAT (Source NAT): חומת האש מחליפה את כתובת המקור הפנימית בכתובת חיצונית, והתשובה חוזרת דרך חומת האש אל השרת.

SNAT עושה תרגום כתובות ותו לא. הוא לא מצפין, כי בשביל זה יש TLS או SSH, והוא לא מפזר בקשות נכנסות בין שרתים דרך VIP (כתובת וירטואלית אחת שמייצגת קבוצת שרתים), שזה תפקידו של DNAT או של Load Balancer.

טעויות נפוצות
  • DMZ מצפין את התעבורה או מסתיר את הכתובות של הרשת הפנימית. הוא רק מקטע נפרד שמוגן בחוקי חומת אש. להצפנה ולהסתרת כתובות יש מנגנונים אחרים.
  • השרת הציבורי ב-DMZ מנותק מהאינטרנט, והפניות אליו עוברות דרך ה-LAN. כל הטעם בשרת שם הוא שהוא נגיש מהאינטרנט. ה-LAN הוא החלק שמוגן ממנו.
  • לשרת ב-DMZ יש כתובת פרטית, אז אין צורך בחוקי חומת אש. כתובת פרטית לא מחליפה הגבלת גישה. בלי חוקים אין הפרדה בין ה-DMZ לבין הפנים.
  • DMZ host בנתב הביתי הוא אותו DMZ שבונים בארגון. DMZ host מפנה את כל הפורטים למחשב אחד, בלי מקטע נפרד ובלי הפרדה.
  • חוסמים את הכניסה מהאינטרנט לשרת, ומשאירים לשרת גישה פנימה. הכיוונים הפוכים. השירות פתוח לאינטרנט בפורט שלו, ומה שנחסם הוא היוזמה של השרת לכיוון הרשת הפנימית.
  • כתובת פרטית לשרת, או רשומת ARP סטטית, יספיקו כדי שפניות מבחוץ יגיעו אליו. תעבורה נכנסת צריכה כלל NAT (Port Forwarding) שמכוון אותה לכתובת הפנימית.
  • שרת ב-DMZ מקבל רוחב פס משלו ומשרת את הלקוחות במהירות גבוהה יותר. DMZ הוא כלי אבטחה. הוא לא מקצה רוחב פס ולא מאיץ דבר.
בדקו את עצמכם
למה מוציאים את שרת ה-DNS החיצוני של הארגון מה-LAN ומציבים אותו ב-DMZ?

כדי שאם הוא ייפרץ, התוקף יישאר ב-DMZ: חוקי חומת האש מגבילים חיבורים ממנו אל ה-LAN.

מה מבדיל חומת אש Multi-homed מחומת אש Single-homed?

ל-Multi-homed יש כמה ממשקים, וכל אחד מחובר לרשת אחרת. ל-Single-homed יש ממשק אחד בלבד.

בנתב ביתי אפשר לבחור בין DMZ host לבין Port Forwarding לפורט 443. במה שונה החשיפה?

DMZ host חושף לאינטרנט את כל הפורטים של המחשב, ו-Port Forwarding חושף רק את פורט 443.

שרת ב-DMZ עם כתובת פרטית צריך להוריד עדכונים מהאינטרנט. מה מאפשר לתשובות לחזור אליו?

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

חזרה לתוכן העניינים

תרחישים: DMZ בפעולה

תרחיש 21: חומה אחת, שלושה ממשקים ושרת דואר שנפרץ

בארגון יש חומת אש אחת עם שלושה ממשקים: לאינטרנט, ל-LAN ול-DMZ. שרת הדואר יושב ב-DMZ בכתובת 172.30.0.10.

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

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

תרחיש 22: איך מכתב מבחוץ מגיע לשרת הדואר

שרת הדואר ב-DMZ בכתובת הפרטית 172.30.0.10, והכתובת הציבורית של הארגון היא 198.51.100.20.

שרת דואר של ארגון אחר מתחבר אל 198.51.100.20 בפורט 25. בנתב מוגדר כלל Port Forwarding: פורט 25 אל 172.30.0.10:25.

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

תרחיש 23: DMZ host על מחשב שעושה הכול

במשרד רואי חשבון קטן הפעילו DMZ host על מחשב שמריץ אתר לקביעת פגישות. על אותו מחשב רצים גם שירות שיתוף מדפסות ושירות שולחן עבודה מרוחק עם חולשה ידועה.

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

התיקון: לבטל את DMZ host ולהגדיר Port Forwarding לפורט של האתר בלבד.

תרחיש 24: שרת שמוריד עדכוני אבטחה

שרת הדואר ב-172.30.0.10 צריך להוריד עדכוני אבטחה משרת עדכונים באינטרנט.

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

חומת האש מבצעת SNAT: היא מחליפה את 172.30.0.10 בכתובת 198.51.100.20. התשובות מגיעות לחומת האש, והיא מעבירה אותן לשרת.

חזרה לתוכן העניינים

הפקודה ipconfig

לראות את ההגדרות: ipconfig ו-ipconfig /all

ב-Windows, ipconfig היא הדרך המהירה לראות מה מוגדר בכל כרטיס רשת (Adapter) במחשב.

בלי שום פרמטר, הפלט קצר: כתובת IP, המסכה (Subnet Mask) וכתובת הנתב שאליו פונים כדי לצאת מהרשת (Default Gateway). כתובת MAC ושרתי DNS לא מופיעים בו.

כשצריך את התמונה המלאה, מוסיפים /all. הטבלה מראה אילו שורות מופיעות בכל גרסה, לפי שמות השורות בפלט האנגלי:

מה מוצגשם השורה בפלטipconfigipconfig /all
כתובת IPIPv4 Addressכןכן
מסכת רשתSubnet Maskכןכן
שער ברירת מחדלDefault Gatewayכןכן
כתובת MACPhysical Addressלאכן
האם הכרטיס מקבל כתובת מ-DHCPDHCP Enabledלאכן
שרת ה-DHCPDHCP Serverלאכן
שרתי DNSDNS Serversלאכן
פרטי החכירהLease Obtained, Lease Expiresלאכן

גם /all רק קוראת ומציגה. היא לא מחדשת חכירה, לא מחזירה הגדרות לברירת מחדל ולא משנה דבר במחשב.

הכלי שייך ל-Windows בלבד. ב-Linux משתמשים ב-ip addr (במערכות ישנות ב-ifconfig), וב-macOS ב-ifconfig. הנה סקריפט קטן בשם check-net.sh שרץ על Linux:

Bash
ipconfig /all
echo "exit code: $?"
ip -br addr show lo
פלט
check-net.sh: line 1: ipconfig: command not found
exit code: 127
lo               UNKNOWN        127.0.0.1/8 ::1/128

קוד היציאה 127 פירושו שהמעטפת לא מצאה פקודה בשם הזה. הפקודה המקבילה של Linux, ip, הציגה את כרטיס ה-loopback עם הכתובת 127.0.0.1.

חזרה לתוכן העניינים

לוותר על כתובת ולבקש חדשה: /release ו-/renew

  • ipconfig /release: המחשב מחזיר לשרת ה-DHCP את הכתובת שקיבל ממנו ומוותר על החכירה. מרגע זה אין לכרטיס כתובת.
  • ipconfig /renew: המחשב פונה לשרת ה-DHCP ומבקש לחדש את החכירה, או לקבל כתובת חדשה.

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

Text
ipconfig /release
ipconfig /renew

שתיהן רלוונטיות רק לכרטיס שמוגדר לקבל כתובת מ-DHCP. לכרטיס שהכתובת שלו הוקלדה ידנית אין חכירה שאפשר לשחרר או לחדש.

היתרון של /renew הוא שמקבלים הקצאה מחודשת בלי לשלוף את הכבל ובלי לאתחל את המחשב. אבל היא עובדת רק מול DHCP: היא לא מאתחלת את כרטיס הרשת ברמת החומרה, לא נוגעת במטמון ה-DNS ולא מרעננת את רשומות ה-ARP.

חזרה לתוכן העניינים

מטמון ה-DNS: /flushdns ו-/displaydns

Windows זוכר תשובות DNS שקיבל, במטמון שנקרא DNS Resolver Cache, כדי לא לשאול שוב על כל שם.

  • ipconfig /displaydns מדפיסה את מה שנמצא במטמון כרגע.
  • ipconfig /flushdns מרוקנת את המטמון. בפעם הבאה שהמחשב יצטרך כתובת של שם, הוא ישאל את שרת ה-DNS מחדש.

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

Text
ipconfig /flushdns
פלט
Windows IP Configuration

Successfully flushed the DNS Resolver Cache.

מה /flushdns לא עושה: היא לא מוותרת על הכתובת שהכרטיס קיבל, לא מציגה שרתי DNS או כתובת MAC ולא מגדירה שרת DNS. היא גם לא נוגעת בטבלת ה-ARP, שהיא מטמון נפרד לגמרי שרואים בעזרת arp -a.

חזרה לתוכן העניינים

פקודות שכנות שקל להתבלבל ביניהן

פקודהמה היא עושה
ipconfig /allפירוט מלא של ההגדרות של כל כרטיס
ipconfig /release, ipconfig /renewויתור על הכתובת מ-DHCP, ובקשה של חכירה
ipconfig /flushdns, ipconfig /displaydnsריקון של מטמון ה-DNS, והצגה שלו
nslookupשולחת שאילתות DNS, וזה כל תפקידה
route printמדפיסה את טבלת הניתוב
arp -aמדפיסה את טבלת ה-ARP
arp -d *מוחקת את הרשומות שבטבלת ה-ARP
netstatמראה חיבורים פתוחים ופורטים שמאזינים
netsh winsock resetמאפסת את מחסנית Winsock, ואין לה קשר להקצאת כתובת IP
טעויות נפוצות
  • ipconfig /release מציגה מידע על הכרטיס. היא פעולה ולא תצוגה: היא משחררת את הכתובת שהתקבלה מ-DHCP.
  • ipconfig לבדה מראה גם את כתובת ה-MAC ואת שרתי ה-DNS. הפלט הקצר כולל רק IP, מסכה ושער. MAC ו-DNS מופיעים ב-/all.
  • /all מרעננת את החכירה או מחזירה את ההגדרות לברירת מחדל. היא רק מציגה ולא משנה דבר.
  • /flushdns מציגה את המטמון ו-/displaydns מוחקת אותו. הפוך: flush מרוקנת, display מציגה.
  • אותן פקודות עובדות גם ב-Linux וב-macOS. ipconfig היא פקודה של Windows. ב-Linux משתמשים ב-ip addr, וב-macOS ב-ifconfig.
  • מספיק להריץ /renew ואחריה /release כדי לקבל כתובת חדשה. הפקודה האחרונה משחררת את הכתובת, והמחשב נשאר בלעדיה. הסדר הנכון: release ואז renew.
  • netstat או route print מציגות את כל ההגדרות של הכרטיס. netstat מציגה חיבורים ופורטים, ו-route print את טבלת הניתוב. את הגדרות הכרטיס מציגה ipconfig /all.
בדקו את עצמכם
טכנאי צריך לדעת מה כתובת ה-MAC של הכרטיס ואיזה שרת DHCP נתן לו כתובת. מה הוא מריץ?

ipconfig /all.

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

ipconfig /flushdns, שמרוקנת את מטמון ה-DNS כדי שהשם יתורגם מחדש.

מחשב Windows שמוגדר ל-DHCP מחזיק כתובת שכבר לא מתאימה לרשת. אילו פקודות מריצים, ובאיזה סדר?

ipconfig /release ואחריה ipconfig /renew.

חזרה לתוכן העניינים

תרחישים: ipconfig בשטח

תרחיש 25: מחשב שלא מגיע לשום מקום

מחשב במשרד לא מצליח לגלוש. ב-ipconfig /all מופיעה הכתובת 169.254.88.14, המסכה 255.255.0.0, ושורת השער ריקה.

זה סימן לכתובת APIPA: שום שרת DHCP לא ענה למחשב, והוא נתן לעצמו כתובת מהטווח 169.254.

שימו לב שהכבל של המחשב דווקא מחובר. כרטיס בלי כבל מוצג כ-Media disconnected ובלי כתובת IPv4 בכלל, ואילו 169.254 אומרת שהקישור פעיל אבל אף שרת DHCP לא השיב.

לכן מחפשים את התקלה בשרת ה-DHCP או בדרך אליו, למשל שירות DHCP שנפל או Relay שלא הוגדר בנתב. אחרי שהשרת חוזר לענות, מריצים ipconfig /renew, ואז שוב ipconfig /all כדי לראות את הכתובת שהוא נתן.

תרחיש 26: כתובת ישנה במטמון

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

הסיבה: מטמון ה-DNS המקומי במחשב שלו (או המטמון של ה-Resolver). הוא מריץ ipconfig /displaydns, רואה את הרשומה הישנה, ואז ipconfig /flushdns מוחקת אותה.

תרחיש 27: שתי פקודות, שתי תוצאות

דנה מריצה ipconfig /all ומקבלת דף מלא של פרטים. שום דבר במחשב שלה לא השתנה.

יוסי מריץ ipconfig /release. המחשב שלו מוותר על הכתובת ונשאר בלי חיבור לרשת, עד שיריץ ipconfig /renew.

חזרה לתוכן העניינים

זמן חיים (TTL)

השדה TTL בכותרת IP

בכל חבילת IP יש שדה בשם TTL (Time To Live). למרות השם הוא לא סופר שניות: זה מספר של 8 ביט, כלומר לכל היותר 255, שמגביל כמה קפיצות (Hops), כלומר כמה נתבים, החבילה יכולה לעבור.

הכלל פשוט: כל נתב שמעביר את החבילה מפחית מה-TTL אחד. נתב שהפחית והגיע ל-0 לא מעביר את החבילה הלאה אלא זורק אותה, ובדרך כלל גם שולח לשולח הודעת ICMP מסוג Time Exceeded.

ב-IPv6 לאותו שדה קוראים Hop Limit.

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

Python
# Each router decrements TTL first, then decides
def send(ttl, routers):
    for hop, name in enumerate(routers, start=1):
        ttl -= 1
        if ttl == 0:
            return f"dropped at {name} (hop {hop}), ICMP Time Exceeded to sender"
    return f"delivered, TTL left = {ttl}"

path = ["R-office", "R-isp", "R-core"]
print(send(4, path))
print(send(3, path))
print(send(1, path))
פלט
delivered, TTL left = 1
dropped at R-core (hop 3), ICMP Time Exceeded to sender
dropped at R-office (hop 1), ICMP Time Exceeded to sender

עם TTL=4 החבילה עוברת שלושה נתבים ומגיעה עם 1. עם 3 היא מתה בנתב השלישי, ועם 1 כבר בנתב הראשון: הוא מפחית ל-0, זורק ומודיע לשולח.

כמה פרטים שנבחנים עליהם:

  • הנתב לא מחזיר את ה-TTL לערך ההתחלתי, לא שולח את החבילה חזרה כמו שהיא, ולא ממשיך להעביר אותה אחרי שהגיעה ל-0.
  • כל נתב בדרך מפחית, לא רק האחרון. ואין מצב שחבילה יוצאת מנתב עם 0 ו"הנתב הבא" זורק אותה: מי שהגיע ל-0 הוא שזורק.
  • ה-TTL רק יורד ואף פעם לא עולה. אין לו קשר לדחיסה, לסדר ההגעה של חבילות או להגדרת הכתובות בתחנה.
  • Hub, Bridge ו-Switch לא משנים את ה-TTL. רק נתב, התקן של שכבה 3, מפחית אותו.
  • להודעת ARP אין TTL, כי אין לה כותרת IP בכלל.
חזרה לתוכן העניינים

איך traceroute מנצל את ה-TTL

הכלי traceroute (ב-Windows קוראים לו tracert) מגלה את רשימת הנתבים שבדרך ליעד בעזרת חבילות שנשלחות כדי למות במקום מסוים:

  1. הבדיקה הראשונה יוצאת עם TTL=1. כבר בנתב הראשון הערך יורד ל-0, החבילה נזרקת והנתב משיב Time Exceeded, ומכתובת המקור של ההודעה הזו traceroute יודע מי הנתב הראשון.
  2. חבילה עם TTL=2 עוברת את הנתב הראשון ומתה בשני, וכך מתגלה הנתב השני.
  3. ממשיכים עם 3, 4 וכן הלאה, עד שהיעד עצמו עונה.
Python
# How traceroute learns the path: one probe per TTL value
routers = ["10.1.1.1", "172.20.0.1", "100.64.3.9"]
target = "192.0.2.80"

for ttl in range(1, 10):
    if ttl <= len(routers):
        # the probe expires at router number ttl, which answers by itself
        print(ttl, routers[ttl - 1], "Time Exceeded")
    else:
        print(ttl, target, "reply from target, stop")
        break
פלט
1 10.1.1.1 Time Exceeded
2 172.20.0.1 Time Exceeded
3 100.64.3.9 Time Exceeded
4 192.0.2.80 reply from target, stop

כל נתב נחשף רק בזכות הודעת ה-ICMP שהוא עצמו שולח. לכן שליחה יחידה עם ערך TTL גדול לא תגלה דבר: נתבים לא רושמים את הכתובת שלהם בתוך הכותרת.

traceroute גם לא שואל שרת DNS מי הנתבים, ולא נעזר ב-ARP, שפועל ממילא רק בתוך הרשת המקומית. וערך הפתיחה שמערכת ההפעלה משתמשת בו בדרך כלל לא משפיע על הבדיקות שלו: הוא בונה את החבילות בעצמו, עם 1, 2, 3 וכן הלאה.

חזרה לתוכן העניינים

ערכי פתיחה: מה אפשר לנחש מה-TTL שמגיע

מערכתTTL התחלתי נפוץ
Linux, macOS, Android64
Windows128
הרבה התקני רשת (אפשר לשנות)255

את ערכי הפתיחה אפשר לראות כשאין שום נתב בדרך: ping לכתובת ה-loopback של המחשב עצמו מחזיר את ה-TTL בדיוק כפי שיצא. כך זה נראה ב-Windows:

Text
ping -n 1 127.0.0.1
פלט
Pinging 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):

Bash
ping -c 1 127.0.0.1
פלט
PING 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.037 ms

--- 127.0.0.1 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.037/0.037/0.037/0.000 ms

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

Python
# Guess the starting value: the nearest typical default at or above what arrived
DEFAULTS = [(64, "Linux/macOS/Android"), (128, "Windows"), (255, "network device")]

def guess(received):
    for start, family in DEFAULTS:
        if received <= start:
            return f"TTL {received}: probably {family}, {start - received} routers away (a guess)"

for value in (52, 116, 249):
    print(guess(value))
פלט
TTL 52: probably Linux/macOS/Android, 12 routers away (a guess)
TTL 116: probably Windows, 12 routers away (a guess)
TTL 249: probably network device, 6 routers away (a guess)
זו הערכה, לא הוכחה: ערכי הפתיחה ניתנים לשינוי. וגם הערך שמגיע לא נקבע רק לפי מערכת ההפעלה, כי כל נתב בדרך גורע ממנו אחד.
חזרה לתוכן העניינים

TTL ב-DNS: אותו שם, משמעות אחרת

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

ה-TTL ברשומהמה מרוויחיםמה משלמים
גבוהפחות שאילתות מגיעות לשרת ה-DNSשינוי ברשומה מתפשט לאט
נמוךשינוי מגיע ללקוחות מהריותר שאילתות לשרת

הפירוט על המטמון של DNS נמצא בפרק על DNS.

טעויות נפוצות
  • ה-TTL בכותרת IP הוא זמן בשניות. בכותרת IP הוא מונה קפיצות. שניות הן המשמעות של TTL ברשומת DNS.
  • כל נתב מוסיף ל-TTL, או מחזיר אותו לערך ההתחלתי. כל נתב רק מפחית ממנו אחד, ואף אחד לא מאפס אותו.
  • חבילה שהגיעה ל-0 ממשיכה עוד נתב אחד, ושם זורקים אותה. הנתב שהפחית ל-0 הוא זה שזורק, ושולח Time Exceeded.
  • גם Switch, Hub ו-Bridge מפחיתים את ה-TTL. רק נתב, כלומר התקן של שכבה 3, נוגע בשדה הזה.
  • traceroute מגלה את הנתבים דרך DNS, דרך ARP או דרך כתובות שהנתבים כותבים בכותרת. הוא נשען רק על הודעות Time Exceeded שכל נתב שולח כשהחבילה מתה אצלו.
  • TTL של 116 מוכיח שבצד השני יש Windows. הוא רק מרמז על כך. ערכי הפתיחה ניתנים לשינוי, ולכן זו הערכה.
  • TTL של רשומת DNS ו-TTL של חבילת IP הם אותו מנגנון. האחד קובע כמה שניות לשמור במטמון, והשני כמה נתבים מותר לעבור.
בדקו את עצמכם
תשובה ל-ping הגיעה עם TTL=59. מה אפשר להעריך?

כנראה ערך פתיחה 64 (Linux, macOS או Android) ו-5 נתבים בדרך. זו הערכה ולא הוכחה.

נתב קיבל חבילה עם TTL=1. מה הוא עושה?

החבילה לא ממשיכה: הנתב מוריד את הערך ל-0, משליך אותה, ובדרך כלל מודיע למקור בהודעת ICMP Time Exceeded.

הגדלתם את ה-TTL של רשומת A מ-300 ל-86400. האם חבילות לשרת יוכלו עכשיו לעבור יותר נתבים?

לא. ה-TTL של הרשומה קובע רק כמה שניות היא נשמרת במטמון (כאן יום שלם), ואין לו קשר לקפיצות.

חזרה לתוכן העניינים

תרחישים: TTL בפעולה

תרחיש 28: שני נתבים שמשחקים פינג פונג

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

בלי TTL היא הייתה ממשיכה כך לנצח ומעמיסה על הקו. חבילה שיצאה ממחשב Windows עם TTL=128 נזרקת אחרי 128 קפיצות, והשולח מקבל Time Exceeded.

תרחיש 29: tracert ממחשב במשרד

מחשב במשרד, שהשער שלו הוא 10.1.1.1, מריץ tracert לשרת באינטרנט.

בבדיקה עם TTL=1 השער עונה Time Exceeded, והכתובת שלו מופיעה בשורה 1. עם TTL=2 עונה הנתב של ספק האינטרנט, והוא מופיע בשורה 2.

כך ממשיכים, שורה אחרי שורה, עד שהשרת עצמו עונה, ושם הבדיקה נעצרת.

תרחיש 30: שתי תשובות, שני מרחקים

ping לשרת אחד מחזיר TTL=61. ערך הפתיחה הנפוץ הקרוב מלמעלה הוא 64, ולכן 64 - 61 = 3 נתבים בדרך.

ping להתקן אחר מחזיר TTL=250. כאן ערך הפתיחה הקרוב הוא 255, כלומר 5 נתבים, וכנראה מדובר בהתקן רשת ולא במחשב.

חזרה לתוכן העניינים

סיכום

לסיום, כל מושגי הפרק בטבלה אחת:

מושגהתפקידמה הכי חשוב לזכור
DNSמתרגם שם לכתובת IPהלקוח שואל Resolver, וה-Resolver עובר בין Root, TLD ושרת Authoritative. nslookup לא מסתכל בקובץ hosts.
Broadcastפנייה לכל התחנות ברשת המקומיתכתובת היעד FF:FF:FF:FF:FF:FF. נתב לא מעביר אותו הלאה. ARP ו-DHCP Discover נשלחים כך.
ARPמוצא MAC לפי IP ברשת המקומיתהשאלה יוצאת ב-Broadcast והתשובה חוזרת ב-Unicast. הטבלה היא מטמון. אין אימות, ומכאן ARP Spoofing. אין לו TTL.
DHCPנותן לתחנה IP, מסכה, שער ו-DNSארבעת שלבי DORA, ב-UDP 67 ו-68. כשאין שרת: APIPA מ-169.254. שרת ברשת אחרת: Relay (Helper Address).
Hubמעתיק כל אות לכל היציאותשכבה 1, תחום התנגשות אחד, בלי טבלת MAC.
Bridgeלומד כתובות MAC ומסנן לפיהןשכבה 2. מציף Broadcast, Multicast ויעדים לא מוכרים. Switch הוא Bridge עם הרבה יציאות.
NATמתרגם כתובות פרטיות לציבוריות בנתבPAT: כתובת אחת, פורט שונה לכל חיבור. Static NAT: זוג קבוע 1:1. חיבור נכנס צריך Port Forwarding.
DMZמקטע נפרד לשרתים הציבורייםחומת האש חוסמת חיבורים מה-DMZ אל הפנים. Multi-homed: חומה אחת עם כמה ממשקים. DMZ host ביתי חושף את כל הפורטים.
ipconfigהגדרות הרשת ב-Windows/all מציגה את כל הפרטים. קודם /release ואז /renew. /flushdns מרוקנת את מטמון ה-DNS.
TTLמגביל את מספר הקפיצות של חבילהכל נתב מפחית אחד, ובהגעה ל-0 זורק ושולח Time Exceeded. Hub, Bridge ו-Switch לא נוגעים בו. ב-DNS זה שניות במטמון.