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) | הנתב שהמחשב שולח אליו כל דבר שמיועד ליעד מחוץ לרשת שלו |
בפרק יש שני סוגים של קוד עם פלט: סימולציות קצרות ב-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 | שם שמצביע על כתובת IPv4 | catalog.library.org אל 172.20.5.40 |
| AAAA | שם שמצביע על כתובת IPv6 | catalog.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) שלו. אם השם לא נמצא שם, הוא יוצא לסבב של שאילתות איטרטיביות, שבו כל שרת עונה רק במה שהוא יודע:
- שרת Root לא מכיר את כתובת האתר. הוא מסתכל על הסיומת ועונה בהפניה: אלה שרתי ה-TLD שאחראים עליה.
- שרת ה-TLD של הסיומת גם הוא לא מחזיק את הכתובת. הוא מפנה לשרת ה-Authoritative של הדומיין.
- שרת ה-Authoritative מחזיק את הרשומות המקוריות, ומחזיר את הכתובת עצמה.
- ה-Resolver שומר את התשובה במטמון ומוסר אותה ללקוח.
הסימולציה הבאה בונה Resolver זעיר: שלושה מילונים ממלאים את תפקידי ה-Root, ה-TLD וה-Authoritative, ומילון רביעי משמש מטמון שהתוקף שלו נקבע לפי TTL. הלקוח שואל על אותו שם בארבעה רגעים שונים:
# 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 שולח ללקוח את כתובת האתר. 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 ארוך | 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 הם בכלל לא קוראים.
# 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 של הספק לא נתקל בשם הזה מעולם.
- המחשב שולח את השאלה ל-Resolver ומחכה.
- ה-Resolver פונה לשרת Root ומקבל הפניה: לשאול את שרתי ה-TLD של
net. - שרת ה-TLD של
netעונה בהפניה נוספת, לשרת ה-Authoritative שלharbor.net. - ה-Authoritative מחזיר רשומת A עם הכתובת.
- ה-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:
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 זהה בכל רשת.
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.
בקשה ותשובה
- הבקשה (ARP Request): התחנה שואלת 'למי שייכת
10.1.1.7?' ושולחת את השאלה ב-Broadcast, לכתובתFF:FF:FF:FF:FF:FF. כל התחנות ברשת המקומית קולטות אותה. - התשובה (ARP Reply): רק התחנה שהכתובת
10.1.1.7שלה עונה, ב-Unicast ישירות לשואלת: 'הכתובת הזו אצלי, וזה ה-MAC שלי'. - השואלת רושמת את הצמד בטבלת ה-ARP שלה ושולחת את המסגרת.
למה הבקשה לא נשלחת רק לנתב? כי השואלת עוד לא יודעת מי מחזיק בכתובת, ואין לה דרך לפנות אליו ישירות. וזו גם לא Multicast, כי אין קבוצה מוגדרת: השאלה הולכת לכולם.
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 מגיעה תשובה שאף אחד לא ביקש:
# 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 בפעם הבאה שתצטרך את הכתובת.
בסביבות שבהן דברים זזים כל הזמן, למשל מכונות וירטואליות שעוברות בין שרתים פיזיים, מרעננים את הטבלה או מקצרים את זמן הפקיעה. המטרה היא שלא יישאר מיפוי ישן ששולח מסגרות למקום שהיעד כבר עזב, ומשבש את התקשורת.
זמן פקיעה קצר מביא עדכונים מהר יותר, אבל הוא מגדיל את תעבורת ה-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), ואין לה רשומה עבורה.
- P שולחת ב-Broadcast: 'למי שייכת
10.1.1.7?'. - כל התחנות קולטות, ורק Q עונה ב-Unicast עם ה-MAC שלה.
- P רושמת רשומה דינמית ושולחת את המסגרת ל-MAC של Q.
- בחבילה הבאה ל-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 |
| תרגום שמות לכתובות IP | DNS |
| החזקת המיפוי בין IP ל-MAC | ARP |
| חלוקת הרשת לקבוצות שידור נפרדות | VLAN |
ארבעת השלבים: DORA
DHCP רץ מעל UDP: השרת מאזין בפורט 67, והלקוח בפורט 68. בתחילת התהליך אין ללקוח כתובת, ולכן הוא פונה ב-Broadcast.
| שלב | השולח | תוכן |
|---|---|---|
| Discover | הלקוח | שידור לכולם מכתובת המקור 0.0.0.0: האם יש כאן שרת DHCP? |
| Offer | השרת | הצעה: כתובת IP וההגדרות שמתלוות אליה |
| Request | הלקוח | הלקוח מודיע שהוא לוקח את הכתובת שהוצעה ומציין מאיזה שרת. בהקצאה הראשונה גם השלב הזה יוצא ב-Broadcast |
| Acknowledge | השרת | אישור סופי: הכתובת שייכת עכשיו ללקוח |
דרך קלה לזכור: הצדדים מתחלפים. הלקוח פותח (Discover), השרת מציע (Offer), הלקוח מבקש (Request), השרת מאשר (Acknowledge).
DHCP Release אינו אחד מארבעת השלבים. זו הודעה שהלקוח שולח כשהוא מחזיר את הכתובת לשרת.
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 Mask | 255.255.0.0 |
גם macOS ומערכות Linux רבות נעזרות באותו טווח Link-Local. בעזרת ipaddress אפשר לראות איך Python מסווג כתובת APIPA לעומת Loopback וכתובת פרטית רגילה:
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: מחשב חדש מקבל כתובת
מחשב נייד מתחבר לרשת של משרד, בלי כתובת.
- Discover: שידור מכתובת
0.0.0.0, מפורט 68 לפורט 67. - Offer: השרת מציע
10.30.4.61, עם מסכה, שער ושרת DNS. - Request: הלקוח לוקח את ההצעה ומציין את השרת שהציע אותה.
- 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. הטבלה מתחילה ריקה, ובכל מסגרת רואים את ההחלטה:
# 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 |
|---|---|---|---|---|---|
| Hub | 1 | אין החלטה: הכול לכולם | אחד, משותף לכל התחנות | אחד, Broadcast עובר | לא |
| Bridge | 2 | MAC של היעד | נפרד לכל צד | אחד, Broadcast עובר | לא |
| Switch | 2 | MAC של היעד | נפרד לכל פורט | אחד, Broadcast עובר | לא |
| נתב | 3 | IP של היעד | נפרד לכל ממשק | נעצר בנתב | כן |
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, והטבלה ריקה.
- K שולחת ל-L. הגשר רושם ש-K בצד 1. את L הוא עוד לא מכיר, ולכן המסגרת מוצפת גם לצד 2.
- L עונה ל-K. הגשר רושם ש-L בצד 1. היעד K כבר ידוע כמי שנמצא בצד 1, והמסגרת הגיעה מצד 1, לכן היא לא עוברת לצד 2.
- 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" בשיחה רגילה, בדרך כלל מתכוונים לזה |
ההבחנה שהכי הרבה נבחנים עליה: Static NAT הוא זוג קבוע של כתובת פנימית וכתובת חיצונית. ב-PAT, לעומת זאת, כתובות פנימיות רבות יושבות על כתובת חיצונית אחת, וכל חיבור מקבל פורט משלו.
איך נתב PAT יודע, כשתשובה מגיעה, לאיזה מחשב בפנים היא שייכת? הוא מנהל טבלת תרגום. בכל חיבור יוצא הוא בוחר פורט מקור חיצוני שעוד לא תפוס, ורושם מולו את הכתובת והפורט הפנימיים של מי שפתח את החיבור.
כשהתשובה חוזרת לכתובת הציבורית, הנתב מחפש בטבלה את פורט היעד שלה ומעביר את החבילה לכתובת הפנימית שרשומה מולו. הקוד הבא מדמה נתב כזה:
# 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 : 49152 | 198.51.100.7 : 61000 |
| 10.0.0.22 : 49152 | 198.51.100.7 : 61001 |
שימו לב גם למה שהנתב לא עושה. כתובת MAC לא חוצה גבולות של רשת, כך שבתשובה שמגיעה מהאינטרנט אין MAC של המחשב הפנימי שאפשר להיעזר בו. הנתב גם לא שולח Broadcast לכל הרשת כדי לברר מי ביקש את התשובה: הטבלה מספיקה לו.
חזרה לתוכן הענייניםחיבורים שמגיעים מבחוץ: Port Forwarding
רשומה בטבלת התרגום נוצרת רק כשמישהו בפנים פותח חיבור. חבילה שהאינטרנט שולח ביוזמתו לא נפתחה מבפנים, ולכן הנתב לא מוצא לה רשומה ולא יודע למי למסור אותה.
כשרוצים ששרת בתוך הרשת יקבל חיבורים מבחוץ, כותבים בנתב כלל Port Forwarding: פורט מסוים בכתובת הציבורית ממופה באופן קבוע אל מכונה מסוימת ברשת, בכתובת ובפורט שלה. הכלל מתרגם את כתובת היעד של חבילה נכנסת, ולכן הוא דוגמה ל-DNAT (Destination NAT).
# 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 closedbefore: 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 | אחת, עם ממשק יחיד | בלי ממשק נפרד; ההפרדה נשענת על רכיבים אחרים, ולכן פחות מומלץ |
חוקי חומת האש, וכלל ה-NAT שמכניס את הלקוחות
למבנה יש שתי מטרות. לקוחות מהאינטרנט צריכים להגיע לשירות, וגם אם השרת ייפרץ, הרשת הפנימית צריכה להישאר מוגנת. שני חוקים עונים על שתיהן:
- מהאינטרנט אל השרת: להתיר רק את פורט השירות הציבורי, למשל 443 לאתר מאובטח.
- מהשרת אל הרשת הפנימית: לחסום חיבורים שהשרת ב-DMZ יוזם לכיוון הפנים.
וכך נראות הגדרות שמחטיאות את המטרה:
| הגדרה שגויה | מה הבעיה בה |
|---|---|
| חסימת החיבורים מהאינטרנט אל השרת | השירות כבר לא נגיש לציבור, וזו כל הסיבה שהשרת קיים |
| היתר לשרת לפנות אל הרשת הפנימית | פריצה לשרת עדיין פותחת דרך פנימה, כאילו לא היה DMZ |
| פתיחת כל הפורטים והישענות על אנטי וירוס בשרת | שטח התקיפה גדל, ואנטי וירוס לא מחליף הגבלת גישה ברמת הרשת |
| תעבורה חופשית בין ה-DMZ לפנים, בשני הכיוונים | ההפרדה פשוט נעלמת |
עוד דבר נחוץ: לרוב השרת ב-DMZ מקבל כתובת פרטית, ופנייה מהאינטרנט לא תמצא אותו לבד. בנתב מגדירים כלל NAT מסוג Port Forwarding, שלוקח פנייה לכתובת הציבורית בפורט מסוים ומעביר אותה לכתובת הפנימית של השרת.
לצד הכלל הזה מוסיפים בדרך כלל חוק בחומת האש שמתיר את השירות הזה בלבד.
שלושה דברים שלא עוזרים כאן, אף שהם נשמעים קשורים:
- רשומת ARP סטטית: היא מצמידה IP ל-MAC רק בתוך הרשת המקומית, ולא מכניסה תעבורה מבחוץ.
- טווח DHCP נפרד ל-DMZ: הוא נותן לשרת כתובת פרטית, וכתובת פרטית לא נגישה מהאינטרנט.
- ערך TTL גבוה יותר: הוא קובע כמה נתבים חבילה רשאית לעבור, לא מי רשאי להגיע לשרת.
DMZ host בנתב ביתי: אותו שם, דבר אחר
בממשק הניהול של נתבים ביתיים מופיעה אפשרות בשם DMZ host. למרות השם, היא לא בונה מקטע נפרד כמו ה-DMZ הארגוני: כל חבילה שמגיעה מבחוץ בלי שמישהו בפנים ביקש אותה, לא משנה לאיזה פורט, נמסרת למחשב אחד שבוחרים מראש.
הבעיה היא היקף החשיפה. לא רק השירות שרציתם לפרסם נגיש מבחוץ, אלא כל שירות שמאזין על המחשב הזה. מספיקה חולשה באחד מהם כדי שתוקף ייכנס למחשב, ומשם ימשיך לשאר הרשת, בייחוד כשאין שום הגבלה נוספת.
ומה לא קורה? ההפניה מתבצעת בתוך ה-NAT של הנתב. השרת ממשיך לענות ללקוחות שלו, ושאר המחשבים בבית גולשים בדיוק כמו קודם, בלי שהחבילות שלהם יעברו דרכו.
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. הטבלה מראה אילו שורות מופיעות בכל גרסה, לפי שמות השורות בפלט האנגלי:
| מה מוצג | שם השורה בפלט | ipconfig | ipconfig /all |
|---|---|---|---|
| כתובת IP | IPv4 Address | כן | כן |
| מסכת רשת | Subnet Mask | כן | כן |
| שער ברירת מחדל | Default Gateway | כן | כן |
| כתובת MAC | Physical Address | לא | כן |
| האם הכרטיס מקבל כתובת מ-DHCP | DHCP Enabled | לא | כן |
| שרת ה-DHCP | DHCP Server | לא | כן |
| שרתי DNS | DNS Servers | לא | כן |
| פרטי החכירה | Lease Obtained, Lease Expires | לא | כן |
גם /all רק קוראת ומציגה. היא לא מחדשת חכירה, לא מחזירה הגדרות לברירת מחדל ולא משנה דבר במחשב.
הכלי שייך ל-Windows בלבד. ב-Linux משתמשים ב-ip addr (במערכות ישנות ב-ifconfig), וב-macOS ב-ifconfig. הנה סקריפט קטן בשם check-net.sh שרץ על Linux:
ipconfig /all
echo "exit code: $?"
ip -br addr show locheck-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. מי שמריץ אותן בסדר ההפוך מחדש כתובת ומיד מוותר עליה, ונשאר בלי כתובת בכלל.
ipconfig /release
ipconfig /renewשתיהן רלוונטיות רק לכרטיס שמוגדר לקבל כתובת מ-DHCP. לכרטיס שהכתובת שלו הוקלדה ידנית אין חכירה שאפשר לשחרר או לחדש.
היתרון של /renew הוא שמקבלים הקצאה מחודשת בלי לשלוף את הכבל ובלי לאתחל את המחשב. אבל היא עובדת רק מול DHCP: היא לא מאתחלת את כרטיס הרשת ברמת החומרה, לא נוגעת במטמון ה-DNS ולא מרעננת את רשומות ה-ARP.
מטמון ה-DNS: /flushdns ו-/displaydns
Windows זוכר תשובות DNS שקיבל, במטמון שנקרא DNS Resolver Cache, כדי לא לשאול שוב על כל שם.
ipconfig /displaydnsמדפיסה את מה שנמצא במטמון כרגע.ipconfig /flushdnsמרוקנת את המטמון. בפעם הבאה שהמחשב יצטרך כתובת של שם, הוא ישאל את שרת ה-DNS מחדש.
מתי זה שימושי? למשל כשאתר עבר לכתובת חדשה והמחשב עדיין פונה לישנה, כי היא שמורה אצלו. כך נראית הרצה של הפקודה:
ipconfig /flushdnsWindows 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 הוא מעין תאריך תפוגה שמבטיח שבסוף היא תיעלם.
# 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) מגלה את רשימת הנתבים שבדרך ליעד בעזרת חבילות שנשלחות כדי למות במקום מסוים:
- הבדיקה הראשונה יוצאת עם TTL=1. כבר בנתב הראשון הערך יורד ל-0, החבילה נזרקת והנתב משיב Time Exceeded, ומכתובת המקור של ההודעה הזו traceroute יודע מי הנתב הראשון.
- חבילה עם TTL=2 עוברת את הנתב הראשון ומתה בשני, וכך מתגלה הנתב השני.
- ממשיכים עם 3, 4 וכן הלאה, עד שהיעד עצמו עונה.
# 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")
break1 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, Android | 64 |
| Windows | 128 |
| הרבה התקני רשת (אפשר לשנות) | 255 |
את ערכי הפתיחה אפשר לראות כשאין שום נתב בדרך: ping לכתובת ה-loopback של המחשב עצמו מחזיר את ה-TTL בדיוק כפי שיצא. כך זה נראה ב-Windows:
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.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 שמגיע אליכם הוא ערך הפתיחה, אחרי שכל נתב בדרך גרע ממנו אחד. כך אפשר להעריך גם את מערכת ההפעלה של הצד השני וגם את המרחק אליו: לוקחים את ערך הפתיחה הנפוץ הקטן ביותר שאינו קטן מהערך שהתקבל.
# 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 זה שניות במטמון. |