Network
POP, IMAP, SSH, Telnet
פרוטוקולי דואר וגישה מרחוק: POP3, IMAP, SSH ו-Telnet, ובקשות HTTP כמו GET ו-POST.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
POP, IMAP, SSH, Telnet: מה עובר ברשת בגלוי ומה מוצפן
כל פרוטוקול בפרק נבנה מאפס סביב ארבע שאלות: מה הוא עושה, איזו בעיה הוא בא לפתור, באיזה פורט הוא ממתין, ומה נחשף ממנו לצד שלישי שמקליט את הרשת. הנושאים, לפי הסדר:
- HTTP, השיטות GET ו-POST: איפה כל שיטה מניחה את הנתונים, מה זה אומר לשיתוף קישור, למטמון ולשליחה חוזרת, ולמה אף אחת מהן אינה הצפנה.
- דואר: SMTP, POP3 ו-IMAP: מי שולח ומי קורא, איך IMAP שומר כמה מכשירים מסונכרנים, ואיך עוטפים אותו בהצפנה (TLS).
- Telnet: גישה מרחוק בלי שום הצפנה, ושני השימושים שעוד נשארו לו: בדיקת פורט TCP ושיחה ידנית עם שירות טקסטואלי.
- SSH: לחיצת היד, מפתח המארח והקובץ known_hosts, הזדהות בזוג מפתחות, הדגלים החשובים של הפקודה, SCP ו-SFTP, מנהרות והעברת פורטים, וקובצי ההגדרות של הלקוח ושל השרת.
המכנה המשותף קל לזכירה: HTTP רגיל, IMAP רגיל ו-Telnet שולחים כל בית כמו שהוא, ו-SSH עוטף את כל השיחה בהצפנה. כל חלק נסגר בתרחישים מעובדים, ברשימה של טעויות נפוצות ובשאלות לבדיקה עצמית.
הפרק נשען על כמה מושגי רשת בסיסיים. הם לא הנושא שלו, אבל כדאי שיהיו ברורים:
| מושג רקע | מה צריך לזכור ממנו |
|---|---|
| לקוח ושרת | הלקוח יוזם את הפנייה, והשרת ממתין לפניות ועונה להן. |
| כתובת IP | מזהה מכונה ברשת. |
| מספר פורט | מזהה שירות מסוים על אותה מכונה. בזכותו אתר, דואר וגישה מרחוק רצים על שרת אחד בלי להתנגש, כל אחד בפורט שלו. |
| TCP | פרוטוקול תעבורה אמין, שמקים חיבור לפני שהוא מעביר נתונים. |
| לחיצת היד המשולשת של TCP | SYN מהלקוח, SYN-ACK מהשרת, ACK מהלקוח. רק אחריה החיבור פתוח. |
HTTP: השיטות GET ו-POST
בקשה, תשובה, וממה בנויה בקשה
HTTP היא שיחה של בקשה ותשובה בין דפדפן לשרת אינטרנט, מעל TCP: בדרך כלל בפורט 80, ובפורט 443 כשמדובר בגרסה המוצפנת, HTTPS. הדרך הקצרה ביותר להבין אותה היא להסתכל על בקשות אמיתיות.
כדי לראות מה באמת יוצא מהמחשב, הפעלנו את nc כמאזין שרק מדפיס כל בית שמגיע אליו, חיכינו שנייה שיתחיל להאזין, ושלחנו אליו בקשת GET בעזרת curl:
nc -l 127.0.0.1 8101 & sleep 1
curl -s -m 1 "http://127.0.0.1:8101/catalog?item=lamp&color=red"GET /catalog?item=lamp&color=red HTTP/1.1
Host: 127.0.0.1:8101
User-Agent: curl/7.81.0
Accept: */*ועכשיו אותו מאזין, והפעם curl -d שולח אליו טופס בשיטת POST:
nc -l 127.0.0.1 8101 & sleep 1
curl -s -m 1 -d 'user=noa&pin=4821' http://127.0.0.1:8101/signinPOST /signin HTTP/1.1
Host: 127.0.0.1:8101
User-Agent: curl/7.81.0
Accept: */*
Content-Length: 17
Content-Type: application/x-www-form-urlencoded
user=noa&pin=4821בכל אחת משתי הלכידות אפשר לסמן את ארבעת הרכיבים שמהם בנויה כל בקשת HTTP:
| רכיב | איפה רואים אותו בלכידה | תפקידו |
|---|---|---|
| שיטה (method) | המילה הראשונה: GET או POST | הפועל של הבקשה: איזו פעולה מבקשים מהשרת |
| נתיב (ה-URL) | מיד אחרי השיטה: /catalog?item=lamp&color=red או /signin | על איזה משאב או פעולה מדובר |
| כותרות (headers) | השורות Host:, User-Agent:, Accept: ועוד | מידע נלווה על הבקשה |
| גוף (body) | מתחת לשורה הריקה, כאן רק בבקשת ה-POST | הנתונים עצמם. הוא רשות, ובבקשת ה-GET אין אותו בכלל |
כבר כאן רואים את ההבדל שעליו נשען כל החלק: ב-GET הנתונים צמודים לנתיב בשורה הראשונה, וב-POST הם יושבים בגוף, עם Content-Type שמתאר את הקידוד שלהם ו-Content-Length שסופר את הבתים. מכאן והלאה מתמקדים בשתי השיטות האלה.
GET: מבקשים משאב, והפרמטרים בכתובת
בשיטת GET הלקוח מבקש מהשרת להחזיר משאב: עמוד, תמונה, רשימת תוצאות. אם יש נתונים לצרף, הם נכתבים בסוף ה-URL: קודם סימן השאלה ?, ואחריו זוגות key=value שהתו & מפריד ביניהם. הקטע הזה נקרא query string, ובעברית מחרוזת שאילתה.
/catalog?item=lamp&color=red
path: /catalog
query string: item=lamp&color=red (everything after ?)
pairs: item=lamp color=red (split on &)עקבו אחרי הכתובת /catalog?item=lamp&color=red מהרגע שלחצתם Enter:
- היא נשארת מוצגת בשורת הכתובת, נכנסת להיסטוריה של הדפדפן, ונרשמת בשורה ביומן (log) שהשרת מנהל על כל בקשה.
- שמרתם אותה במועדפים או הדבקתם אותה בהודעה לחברה? היא עוברת שלמה, ומי שלוחץ עליה מקבל בדיוק את אותו עמוד, כי כל הבקשה כתובה בה.
- ניסיתם לדחוס לתוכה עשרות אלפי תווים? היא תיכשל. כל דפדפן וכל שרת מציבים לה גבול משלהם, למרות שהתקן לא נוקב במספר (ובטח לא ב-255), כפי שיראה תרחיש ה-414 בהמשך.
חשבו על GET כמו על מבט בלוח מודעות: מסתכלים, ולא מזיזים אף פתק. מהעיקרון הזה נגזרות שלוש תכונות שמופיעות שוב ושוב בשאלות:
| תכונה | המשמעות | איך זה נראה בפועל |
|---|---|---|
| safe (בטוחה) | הבקשה רק קוראת, ולא משנה דבר בשרת | דפדוף לעמוד 3 של תוצאות החיפוש לא משנה אף רשומה |
| idempotent (אידמפוטנטית) | חזרה על הבקשה משאירה את השרת באותו מצב כמו שליחה אחת | רענון של עמוד מוצר חמש פעמים לא משנה את המוצר |
| cache (מטמון) | את התשובה אפשר לשמור ולהגיש שוב בלי לפנות לשרת | הדפדפן או שרת ביניים מגישים עותק שמור של אותו עמוד |
לכן GET היא הבחירה הטבעית לחיפוש, לדפדוף בין עמודים ולהצגה של פריט. ומאותה סיבה היא הבחירה השגויה לכל דבר שמשנה נתונים, כמו שיראה התרחיש של כפתור המחיקה בהמשך.
חזרה לתוכן הענייניםPOST: הנתונים עוברים בגוף הבקשה
חזרו ללכידת ה-POST מתחילת החלק ועברו עליה מלמעלה למטה. כל תכונה חשובה של השיטה נובעת ממשהו שרואים שם:
- השורה הראשונה היא רק
POST /signin. הכתובת לא נושאת אתuserואתpin, ולכן הם לא יופיעו בשורת הכתובת, בהיסטוריה או בסימניות, וקישור שתעתיקו לא יכיל אותם. זה ההפך הגמור מ-/catalog?item=lamp&color=red. - הנתונים יושבים מתחת לשורה הריקה, ו-
Content-Lengthמודיע כמה בתים יש שם. הגוף נמדד בבתים ולא נדחס לתוך שורה, ולכן הוא יכול לשאת טקסט של כמה עמודים או קובץ שלם, בלי תקרת האורך של כתובת. - הנתיב
/signinהוא פעולה, לא משאב לקריאה. POST היא הדרך למסור לשרת נתונים כדי שיעשה בהם משהו: לפתוח חשבון, לקבל הזמנה, להכניס משתמש, לשמור מסמך שהועלה. ולכן היא השיטה של טפסים.
מהנקודה האחרונה נובעת התכונה החשובה מכולן. אם הבקשה גורמת לשרת לעשות משהו, שליחה שנייה שלה עלולה לגרום לו לעשות את זה שוב, למשל לחייב כרטיס אשראי פעמיים. לכן POST אינה idempotent (אינה אידמפוטנטית), ומכאן השאלה שהדפדפן שואל כשמרעננים עמוד שהגיע אחרי שליחת טופס: האם באמת לשלוח שוב.
ומה עם מטמון? התשובה ל-POST בדרך כלל לא נשמרת בו כברירת מחדל, וזה עוד הבדל מ-GET.
ו-POST גם לא מחייבת חלון אישור מיוחד: הלחיצה על כפתור השליחה היא כל מה שנדרש כדי שהיא תצא.
חזרה לתוכן הענייניםGET או POST: שלושה מקרים, טבלה וכלל החלטה
תרחיש 1: הקישור שהגיע ריק
ספרנית מחפשת בקטלוג של הספרייה ספרים על אסטרונומיה, ושולחת לעמית את הכתובת מהדפדפן. העמית פותח אותה ומקבל טופס חיפוש ריק, בלי אף תוצאה.
מה קרה? טופס החיפוש של הקטלוג שולח את מילות החיפוש ב-POST, כלומר בגוף. הכתובת שהועתקה היא רק /catalog/search, והיא לא נושאת את המילה astronomy.
התיקון: לשלוח את החיפוש ב-GET, ואז הכתובת תהיה /catalog/search?q=astronomy. החיפוש לא משנה שום רשומה, כך שאין כאן שום מחיר, ומעכשיו הקישור משחזר את התוצאות אצל כל מי שפותח אותו.
תרחיש 2: שרת שמחזיר 414
טופס משוב נבנה בטעות כטופס GET, וגולשת מדביקה בו טקסט ארוך מאוד. כאן מדמים את זה עם שרת האינטרנט המובנה של Python וכתובת של 70,000 תווים:
essay=$(python3 -c "print('a' * 70000)")
curl -s -i "http://127.0.0.1:8088/feedback?text=$essay" | head -1HTTP/1.0 414 Request-URI Too Longהשרת סירב לקרוא את הבקשה בכלל, וקוד 414 אומר שהכתובת ארוכה מדי. הגבול כאן נקבע במימוש של השרת הזה, ושרתים ודפדפנים אחרים קובעים גבולות משלהם, כי התקן לא מגדיר מספר (וודאי שלא 255). אין כאן גם עניין של דחיסה: פשוט אין מקום.
התיקון הוא להעביר את הטופס ל-POST, שם הטקסט נוסע בגוף, ולגוף אין תקרה כזו.
תרחיש 3: החנות שהתרוקנה בלילה
בבוקר גילו בחנות מקוונת שכל המוצרים בקטגוריה אחת נמחקו. ביומן השרת מופיעה שורה אחרי שורה כמו GET /products/remove?id=88, וכולן הגיעו מסורק של מנוע חיפוש.
ההסבר: בממשק הניהול, ליד כל מוצר, היה קישור רגיל למחיקה, ולחיצה על קישור היא GET. הסורק עבר על כל הקישורים בעמוד, כי GET אמורה להיות safe ולכן מותר לבקש אותה בלי לשאול. אותו דבר יכול לקרות בגלל טעינה מוקדמת (prefetch) של הדפדפן, ובנוסף תשובות GET עלולות להישמר במטמון ולהציג תמונה לא עדכנית.
הלקח: מחיקה, עדכון וכל שינוי אחר שולחים ב-POST, בדרך כלל מכפתור בתוך טופס.
| היבט | GET | POST |
|---|---|---|
| מיקום הנתונים | ב-URL, אחרי ? | בגוף הבקשה |
| ייעוד | שליפת מידע | שליחת טופס, יצירה או עדכון של נתונים |
| שינוי בשרת | לא אמורה לשנות (safe) | בדרך כלל משנה |
| שליחה כפולה | אותו מצב כמו שליחה אחת (idempotent) | עלולה לבצע את הפעולה פעמיים |
| מועדפים ושיתוף קישור | אפשרי, הפרמטרים חלק מהכתובת | לא אפשרי, הכתובת לא נושאת אותם |
| היסטוריה ויומני שרת | הפרמטרים נרשמים יחד עם הכתובת | לא נרשמים כחלק מהכתובת |
| נפח | מוגבל בפועל באורך ה-URL | מתאים לנפח גדול |
| מטמון (cache) | מתאימה לשמירה | בדרך כלל לא נשמרת |
| הצפנה | אין | אין. רק HTTPS מצפין, ושתי השיטות נהנות ממנו באותה מידה |
שלושת המקרים מתכנסים לשלוש שאלות שכדאי לשאול לפני שבוחרים שיטה:
- האם הבקשה משנה משהו בשרת? אם כן, POST (החנות שהתרוקנה).
- האם הנתונים עלולים להיות ארוכים? אם כן, POST (השרת שהחזיר 414).
- האם יש בעיה שהנתונים יישארו בכתובת, בהיסטוריה וביומנים, למשל כי הם רגישים? אם כן, POST.
אם התשובה לשלושתן היא לא, ויש ערך בקישור שאפשר לשמור או לשלוח (הקטלוג של הספרייה), בוחרים GET.
חזרה לתוכן הענייניםהשיטה לא מצפינה: HTTP רגיל מול HTTPS
חזרו ללכידות של nc מתחילת החלק. אילו במקום nc היה יושב בדרך מישהו עם Wireshark, הוא היה רואה בדיוק את אותו טקסט, ושם pin=4821 מופיע כמו שהוקלד, גם בבקשת POST.
כלומר שיטת הבקשה לא מוסיפה שום שכבת הגנה. מה שמבדיל בין GET ל-POST הוא רק המיקום של הנתונים, ומיקום אחר אינו הצפנה.
ובכל זאת, סיסמה ב-GET גרועה יותר, והסיבה היא לא הרשת. המיקום בכתובת גורם לה להיחרט גם במקומות שנשארים אחרי שהבקשה הסתיימה:
| מי רואה את הסיסמה | GET ב-HTTP רגיל | POST ב-HTTP רגיל |
|---|---|---|
| מאזין לרשת | רואה, היא בשורה הראשונה | רואה, היא בגוף |
| היסטוריה, סימניות ויומני שרת | רואים, כי היא חלק מהכתובת | לא רואים, הכתובת נקייה |
ההגנה מפני המאזין מגיעה רק מ-HTTPS, ושם חשוב לדעת בדיוק מה מוצפן ומה לא, בלי קשר לשיטה:
| ב-HTTPS, מוצפן | ב-HTTPS, עדיין גלוי למאזין |
|---|---|
| השיטה, הנתיב וה-query string | כתובות ה-IP והפורטים של שני הצדדים |
| כל הכותרות, כולל cookies | שם השרת שאליו פונים, שנשלח בתחילת החיבור (בשדה SNI) |
| הגוף | נפח התעבורה והתזמון שלה |
שימו לב שהטבלה עוסקת רק ברשת. גם ב-HTTPS, פרמטר של GET עדיין נשמר בהיסטוריה של הדפדפן וביומן השרת, כי שני אלה רושמים את הכתובת המלאה אחרי הפענוח.
application/x-www-form-urlencoded ו-Base64 הם ייצוגים הפיכים שכל אחד יכול לפענח בשנייה, ולכן הם לא מסתירים דבר.תרחיש 4: שני צופים, שתי שיטות
פורטל של מרפאה עובד בכתובת שמתחילה ב-http://. מטופל נכנס אליו ממחשב משותף בבית, דרך ה-Wi-Fi של בית קפה. יש שני צופים פוטנציאליים: בן משפחה שיפתח מחר את ההיסטוריה של הדפדפן, וזר באותה רשת Wi-Fi שמריץ Wireshark.
| טופס הכניסה ב-GET | טופס הכניסה ב-POST | |
|---|---|---|
| בן המשפחה, בהיסטוריה | מוצא את הסיסמה בכתובת | לא מוצא כלום |
| הזר, בלכידה | קורא את הסיסמה | קורא את הסיסמה |
המעבר ל-POST הוציא מהתמונה רק את הצופה הראשון. כדי לנטרל גם את השני, הפורטל חייב לעבור ל-HTTPS.
איך גוף ה-POST מקודד: urlencoded ו-multipart/form-data
לגוף של טופס POST יש שני קידודים נפוצים, והדפדפן בוחר ביניהם לפי הגדרת הטופס.
application/x-www-form-urlencoded: הגוף הוא שורה אחת של זוגותkey=valueעם&ביניהם, כמו בלכידת ה-POST שלמעלה. מתאים לשדות טקסט פשוטים, ומסורבל לקבצים.multipart/form-data: הגוף נחתך לחלקים (parts), ומחרוזת גבול (boundary) מפרידה ביניהם. כל חלק הוא שדה טקסט או קובץ שלם, גם בינארי, והשרת מפרק כל חלק לעצמו.
כך אפשר לשלוח בגוף אחד גם שדות טקסט וגם קבצים. הנה לכידה של טופס עם כיתוב ועם תמונה, שוב מול nc (ערך ה-boundary נבחר באקראי בכל הרצה, ולכן אצלכם הוא יהיה אחר):
printf 'fake-png-bytes' > map.png
nc -l 127.0.0.1 8101 & sleep 1
curl -s -m 1 -F 'caption=Harbor at night' -F 'image=@map.png;type=image/png' http://127.0.0.1:8101/sharePOST /share HTTP/1.1
Host: 127.0.0.1:8101
User-Agent: curl/7.81.0
Accept: */*
Content-Length: 310
Content-Type: multipart/form-data; boundary=------------------------7ddbbf7f88385335
--------------------------7ddbbf7f88385335
Content-Disposition: form-data; name="caption"
Harbor at night
--------------------------7ddbbf7f88385335
Content-Disposition: form-data; name="image"; filename="map.png"
Content-Type: image/png
fake-png-bytes
--------------------------7ddbbf7f88385335--קראו את הלכידה מלמעלה למטה. הכותרת Content-Type מכריזה על הגבול; כל חלק נפתח בשורת הגבול ומתאר את עצמו ב-Content-Disposition; החלק של התמונה מוסיף filename ו-Content-Type משלו; וגבול עם שני מקפים נוספים בסופו סוגר את הגוף.
עכשיו חפשו מה לא השתנה. Harbor at night ו-fake-png-bytes יושבים בגוף כמו שהם, בלי הצפנה ובלי דחיסה. השורה הראשונה, POST /share, קצרה כמו בכל טופס, כי גם כאן הכול בגוף ולא בכתובת.
וגם התכונות של POST נשארו כמו שהן: שליחה כפולה של הטופס הזה תעלה את התמונה פעמיים. multipart משנה רק את מבנה הגוף, כדי ששדות וקבצים יוכלו לנסוע יחד.
חזרה לתוכן הענייניםטעויות נפוצות ובדיקה עצמית: GET ו-POST
טעויות נפוצות
- POST מצפינה את מה שנשלח בגוף. ב-HTTP רגיל הגוף נקרא בלכידה כמו כל שאר הבקשה. הצפנה מגיעה מ-HTTPS ולא מהשיטה.
- ב-GET הכתובת מוסתרת, ולכן אין בעיה לשתף קישור שיש בו פרמטרים רגישים. ב-HTTP רגיל הכתובת עוברת גלויה, ובכל מקרה הפרמטרים נשארים בהיסטוריה וביומני השרת.
- GET מכניסה את הנתונים לגוף, ו-POST מצמידה אותם ל-URL. בדיוק הפוך: GET בכתובת אחרי
?, POST בגוף. - אפשר לשלוח POST שוב ושוב בלי חשש, כמו GET. POST אינה אידמפוטנטית. שליחה כפולה עלולה לבצע את הפעולה פעמיים, ולכן הדפדפן מזהיר.
- ב-HTTPS אי אפשר להשתמש ב-GET. GET עובדת מצוין ב-HTTPS, ושם הנתיב והפרמטרים מוצפנים כמו הגוף של POST.
- הפרמטרים של טופס GET נשלחים בכותרות או בתוך cookie. הם נשלחים במחרוזת השאילתה, אחרי ה-
?שבכתובת. - דפדפנים שומרים במטמון תשובות ל-POST, ו-GET תמיד נשלחת מחדש. ההפך. GET היא השיטה שמתאימה למטמון, ותשובות ל-POST בדרך כלל לא נשמרות.
- לפי התקן, כתובת של GET חסומה ב-255 תווים. בתקן אין מספר קבוע. המגבלה מעשית, והיא של דפדפנים ושל שרתים.
- POST מקפיצה חלון אישור לפני שהיא יוצאת. אין חלון כזה: לחיצה על כפתור השליחה שולחת אותה מיד. האזהרה מופיעה רק כשמנסים לשלוח את אותו טופס שוב.
- multipart/form-data דוחס את הטופס או מצפין אותו. הוא רק מחלק את הגוף לחלקים כדי לצרף קבצים לצד שדות, והתוכן נשאר גלוי.
בדקו את עצמכם
אפליקציה שולחת תשלום, החיבור נקטע, והיא מנסה שוב אוטומטית. למה זה מסוכן כשהתשלום נשלח ב-POST, אבל לא מסוכן כשאותה אפליקציה מבקשת ב-GET להציג את היתרה?
POST אינה אידמפוטנטית, ולכן ניסיון חוזר עלול לחייב פעמיים. GET שמציגה יתרה רק קוראת, וחזרה עליה משאירה את השרת באותו מצב.
ביומן של שרת שעובד ב-HTTP רגיל מופיעות שתי שורות: GET /signin?user=noa&pin=4821 ו-POST /signin. איזו בקשה הדליפה את הקוד ליומן? והאם הבקשה השנייה מוגנת מפני מאזין ברשת?
הראשונה, כי הקוד הוא חלק מהכתובת והיומן רושם כתובות. השנייה לא נרשמה ביומן, אבל הגוף שלה עבר ברשת בלי הצפנה, ומאזין היה קורא אותו.
אתר עבר ל-HTTPS. האם עכשיו אין שום בעיה לשלוח קוד סודי ב-GET?
מאזין ברשת כבר לא יראה אותו, כי ה-query string מוצפן. אבל הקוד עדיין יישמר בהיסטוריה של הדפדפן וביומן השרת, ולכן עדיף POST.
מה multipart/form-data מאפשר ש-urlencoded לא עושה בנוחות?
לשלוח באותו גוף קבצים, גם בינאריים, לצד שדות טקסט, כשכל חלק מופרד בגבול ומפוענח בנפרד.
דואר אלקטרוני: SMTP, POP3 ו-IMAP
חלוקת העבודה: SMTP שולח, IMAP ו-POP3 קוראים
עקבו אחרי הודעה אחת. דנה כותבת לאבי, ותוכנת הדואר שלה מוסרת את ההודעה ב-SMTP, עד שהיא נוחתת בתיבה של אבי על שרת הדואר שלו. מאוחר יותר אבי פותח את הטלפון, והתוכנה שלו ניגשת לתיבה ב-IMAP או ב-POP3.
כלומר שליחה וקריאה הן שני פרוטוקולים שונים, ולכל אחד מהם פורטים משלו:
| פרוטוקול | מה הוא עושה | פורט בלי הצפנה | פורט עם הצפנה |
|---|---|---|---|
| SMTP | שולח דואר | 25, 587 | 465, או 587 עם STARTTLS |
| IMAP | ניגש לתיבה שנשארת בשרת | 143 | 993 |
| POP3 | מוריד את הדואר אל המכשיר | 110 | 995 |
השם IMAP הוא קיצור של Internet Message Access Protocol, והמילה החשובה בו היא Access. התוכנה שלכם ניגשת לתיבה שבשרת ומציגה ממנה תיקיות והודעות, בלי לקחת אותן הביתה. שאלות רבות בודקות אם ברור לכם מה שייך לו ומה לא:
| משימה | מי עושה אותה |
|---|---|
| לקרוא את ההודעות שבתיבה בשרת | IMAP (או POP3) |
| לשלוח הודעה ליעד | SMTP, לא IMAP |
| לתרגם שם של שרת דואר לכתובת IP | DNS, לא IMAP |
| להעביר קבצים בין מחשבים | פרוטוקולים כמו SFTP, לא IMAP |
המודל של IMAP: השרת הוא מקור האמת
השוו את IMAP למסמך משותף בענן, ואת POP3 לקובץ שהורדתם למחשב. במסמך המשותף יש עותק אחד, וכל מי שפותח אותו רואה את הגרסה האחרונה. בקובץ שהורד, כל מחשב מחזיק עותק משלו, ושינוי באחד לא מגיע לאחרים.
ב-IMAP העותק האחד יושב בשרת, והוא כולל לא רק את ההודעות אלא גם את התיקיות ואת סימון הנקרא או לא נקרא של כל הודעה. כל מחיקה, קריאה או העברה לתיקייה שאתם עושים במכשיר אחד נשלחת לשרת, ולכן מופיעה מיד בכל המכשירים. זה קורה מעצמו, בלי לחיצה על כפתור סנכרון ובלי שרת proxy באמצע שממיר פורמטים.
צורת הקשרים היא כוכב: במרכז השרת, וכל מכשיר מחובר אליו בלבד. אין קו ישיר בין הטלפון למחשב, וכולם מצביעים על אותה תיבה אחת, לא על תיבה פרטית לכל מכשיר.
- IMAP רץ מעל TCP.
- הוא מנהל תיקיות רבות בצד השרת.
- כמה תוכנות יכולות לפתוח את אותה תיבה באותו זמן.
- ברשימת הודעות ארוכה מספיקים לו בהתחלה השולח והנושא של כל הודעה. את התוכן המלא הוא מושך רק כשלוחצים על הודעה.
| IMAP | POP3 (במצב הרגיל) | |
|---|---|---|
| היכן ההודעות | נשארות בשרת | יורדות למכשיר ונמחקות מהשרת |
| כמה מכשירים | כולם רואים את אותה תיבה | לכל מכשיר עותק נפרד |
| תיקיות וסימוני קריאה | מסונכרנים | לא מסונכרנים |
| היתרון העיקרי | סנכרון מלא בין המכשירים | פשטות, והדואר שמור אצלכם |
תרחיש 5: למה המחשב לא יודע מה עשיתי בטלפון?
יעל מתלוננת: בטלפון היא קראה את ההודעה מבעל הדירה והעבירה חשבונית לתיקייה Taxes, אבל במחשב שבעבודה ההודעה עדיין מודגשת כלא נקראה, והחשבונית בכלל לא שם. יותר מזה, כמה הודעות ישנות שקראה במחשב לא מופיעות בטלפון.
האבחנה: תוכנת הדואר במחשב הוגדרה ב-POP3. היא הורידה את ההודעות אליה ומחקה אותן מהשרת, ומאז היא חיה בעולם משלה.
אחרי שמגדירים גם את המחשב ב-IMAP, שני המכשירים מדברים עם אותה תיבה בשרת. מעכשיו מה שיעל עושה בטלפון מופיע במחשב: ההודעה מבעל הדירה מסומנת כנקראה, החשבונית נמצאת ב-Taxes, ושום הודעה לא נעלמת מהשרת רק כי קראו אותה.
IMAP מוצפן: IMAPS בפורט 993 או STARTTLS בפורט 143
TLS היא שכבת הצפנה שנכנסת בין TCP לבין פרוטוקול האפליקציה. IMAP ממשיך לדבר באותן פקודות בדיוק, אבל כל בית שלו עובר מוצפן. בלי TLS, IMAP בפורט 143 גלוי לכל מי שמאזין לקו.
יש שתי דרכים להכניס את TLS לתמונה, והן נבדלות ברגע שבו ההצפנה מתחילה:
- IMAPS: פורט נפרד, 993. החיבור מוצפן מהבית הראשון, עוד לפני ששורת הברכה של השרת מגיעה.
- STARTTLS: מתחברים לפורט 143 הרגיל, ובשלב מסוים הלקוח שולח את הפקודה
STARTTLS, ואותו חיבור עצמו משודרג להצפנה.
כדי לראות את STARTTLS בפעולה, הנה לקוח שמנסה להזדהות מוקדם מדי מול שרת שהמנהל שלו הגדיר שאסור להזדהות לפני הצפנה:
S: * OK IMAP4rev1 ready
C: t1 LOGIN avi Sunflower9
S: t1 NO [PRIVACYREQUIRED] login not allowed before STARTTLS
C: t2 CAPABILITY
S: * CAPABILITY IMAP4rev1 STARTTLS LOGINDISABLED IDLE
S: t2 OK done
C: t3 STARTTLS
S: t3 OK begin TLS now
(TLS handshake; every byte below travels encrypted)
C: t4 LOGIN avi Sunflower9
S: t4 OK welcome- t1: הלקוח ניסה לשלוח סיסמה בחיבור גלוי, והשרת סירב. זה בדיוק מה שהמנהל רצה: הסיסמה לא תצא לפני הצפנה, והפורט נשאר 143.
- t2: הלקוח שואל ב-
CAPABILITYמה השרת מציע. בתשובה מופיעיםSTARTTLS, כלומר אפשר לשדרג, ו-LOGINDISABLED, הסימן שהזדהות חסומה כל עוד החיבור גלוי. - t3:
STARTTLSמשדרג את אותו חיבור, על אותו פורט 143. CAPABILITY רק דיווחה, ו-STARTTLS היא שבאמת שינתה את החיבור. - t4: עכשיו אותה פקודת LOGIN מתקבלת, והפעם היא עוברת מוצפנת.
בפורט 993 השיחה הזו הייתה נראית אחרת: אין t1 נכשל ואין t3, כי הכול מוצפן מראש.
הצעות שעולות לפעמים, ולמה רובן לא עובדות:
| הצעה | מצפינה? | למה |
|---|---|---|
| לעבור ל-POP3 | לא | גם POP3 בפורט 110 גלוי. הגרסה המוצפנת שלו נמצאת בפורט 995 |
| להאריך את הסיסמה | לא | סיסמה ארוכה נקראת בלכידה בדיוק כמו קצרה |
| להעביר את השירות לפורט אחר | לא | זה רק משנה איפה השירות ממתין, והתוכן נשאר קריא |
| לשלוח את הפרטים ב-Base64 | לא | קידוד הפיך, כפי שיוצג מיד |
| להריץ CAPABILITY | לא | הפקודה רק מדווחת על יכולות ולא משנה דבר בחיבור |
| STARTTLS ב-143 או IMAPS ב-993 | כן | TLS מצפין את כל השיחה |
| מנהרת SSH אל השרת | כן | תעבורת ה-IMAP נוסעת בתוך חיבור SSH מוצפן |
השורה האחרונה היא הפתרון כשהשרת לא מציע TLS בכלל, לא IMAPS ולא STARTTLS, אבל יש אליו גישת SSH. מקימים מנהרה (Port Forwarding), למשל ssh -L 9143:127.0.0.1:143 tech@legacy-mail.example, ובתוכנת הדואר מגדירים שהשרת הוא 127.0.0.1 בפורט 9143. המנהרות עצמן מוסברות לעומק בחלק על SSH.
| קטע בדרך | מה עובר בו | מה רואה מאזין |
|---|---|---|
מתוכנת הדואר אל 127.0.0.1:9143 | IMAP רגיל, בתוך המחשב עצמו | אין מאזין, התעבורה לא יוצאת מהמחשב |
| מהמחשב אל legacy-mail.example, פורט 22 | חיבור SSH שעוטף את ה-IMAP | רק תעבורת SSH מוצפנת |
| בתוך השרת, אל פורט 143 שלו | IMAP רגיל שוב | שום דבר ברשת, זה קורה בתוך השרת |
הזדהות ב-IMAP: למה PLAIN צריך TLS
הזדהות ב-IMAP היא שם משתמש וסיסמה. במנגנון PLAIN, שמופעל בפקודה AUTHENTICATE PLAIN, שני הפרטים יוצאים מקודדים ב-Base64.
נניח שהקלטתם חיבור IMAP גלוי ומצאתם בו את המחרוזת AG1heWEAVHVsaXAjNzc=. כמה עבודה נדרשת כדי לגלות את הסיסמה?
import base64
blob = base64.b64encode(b'\0maya\0Tulip#77').decode() # what PLAIN puts on the wire
print(blob)
print(base64.b64decode(blob)) # what an eavesdropper recoversAG1heWEAVHVsaXAjNzc=
b'\x00maya\x00Tulip#77'שורה אחת. המשתמש maya והסיסמה Tulip#77 חוזרים בדיוק כפי שהוקלדו, והבתים \x00 הם רק המפרידים שהמנגנון שם ביניהם. אין שם מפתח RSA שצריך לשבור, וגם לא זיהוי לפי הכתובת שממנה הלקוח מתחבר: יש פענוח Base64, וזהו.
מכאן שבלי TLS הפרטים חשופים לגמרי, וההגנה היא להריץ את IMAP מעל TLS: STARTTLS בפורט 143 או IMAPS בפורט 993.
| מנגנון | מה עובר בקו | מה מאזין מרוויח בלי TLS |
|---|---|---|
| PLAIN | שם המשתמש והסיסמה, מקודדים ב-Base64 | את הסיסמה עצמה |
| CRAM-MD5 | השרת שולח אתגר, ערך אקראי, והלקוח מחזיר גיבוב שחושב מהאתגר ומהסיסמה | לא את הסיסמה, כי היא לא נשלחת בכלל |
פקודות IMAP, תגיות ו-IDLE
בשיחה שלמעלה כל שורה של הלקוח נפתחה במילה קצרה, t1, t2 וכן הלאה. זו התגית (tag): הלקוח בוחר אותה, והשרת חוזר עליה בשורה שמסיימת את הטיפול בפקודה, כך שגם כשהשרת שולח כמה שורות ביניים, ברור איזו פקודה הסתיימה. IMAP כולו בנוי כך, משורות טקסט של פקודה ותשובה.
אחרי ההזדהות, שיחה טיפוסית ממשיכה כך (S הוא השרת, C הוא הלקוח):
C: k4 LIST "" "*"
S: * LIST () "/" INBOX
S: * LIST () "/" Taxes
S: k4 OK done
C: k5 EXAMINE Taxes
S: k5 OK [READ-ONLY] done
C: k6 SELECT INBOX
S: k6 OK [READ-WRITE] done
C: k7 IDLE
S: + waiting
S: * 12 EXISTS
C: DONE
S: k7 OK idle finished
C: k8 LOGOUT
S: * BYE
S: k8 OK done| פקודה | מה היא עושה |
|---|---|
| CAPABILITY | מחזירה את היכולות וההרחבות שהשרת תומך בהן, למשל STARTTLS, IDLE ושיטות הזדהות. שולחים אותה לפני STARTTLS. |
| STARTTLS | משדרגת חיבור בפורט 143 לחיבור מוצפן. |
| LIST | מחזירה את רשימת תיבות הדואר (התיקיות) שבחשבון. |
| SELECT | פותחת תיבה אחת לעבודה, לקריאה ולכתיבה. |
| EXAMINE | פותחת תיבה אחת כמו SELECT, אבל לקריאה בלבד: אי אפשר לשנות הודעות או דגלים, ואי אפשר למחוק. |
| EXPUNGE | מוחקת סופית את ההודעות שסומנו למחיקה. |
| NOOP | לא עושה דבר, חוץ מלתת לשרת הזדמנות לדווח על שינויים. לקוחות שולחים אותה מדי פעם כדי לבדוק (polling). |
| IDLE | משאירה את החיבור פתוח, כדי שהשרת ידווח מיוזמתו על הודעות חדשות. |
| LOGOUT | סוגרת את הסשן ומנתקת את הלקוח. |
שתי דרכים לדעת שהגיע דואר חדש, ומה כל אחת עולה:
| polling, למשל NOOP כל דקה | IDLE | |
|---|---|---|
| מי יוזם | הלקוח, שוב ושוב | השרת, כשיש מה לדווח |
| מתי מגיע העדכון | רק בבדיקה הבאה | מיד, כמו * 12 EXISTS בשיחה למעלה (push) |
| עלות | בקשות מיותרות, סוללה ותעבורה | חיבור פתוח אחד שממתין, צריכה נמוכה, ולכן מתאים לטלפונים |
IDLE היא רק דרך להמתין. היא לא מגדירה מרווח בין בדיקות, לא מקטינה הודעות, לא עוצרת דואר נכנס ולא מוסיפה הצפנה.
תרחיש 6: ארבע משימות, ארבע פקודות
עוזר אוטומטי לניהול דואר צריך לבצע ארבע משימות. התאימו לכל אחת פקודה, ושימו לב לזוגות שקל לבלבל:
- לנקות לצמיתות את ההודעות שכבר סומנו למחיקה: EXPUNGE. לא EXAMINE, שרק פותחת תיבה לצפייה.
- להציג למשתמש אילו תיקיות יש בחשבון: LIST. לא SELECT, שפותחת תיקייה אחת ולא מונה את כולן.
- לעבור על Taxes ולסכם אותה בלי שום סיכון לשנות סימון: EXAMINE, כי היא לקריאה בלבד.
- לסמן הודעות ב-INBOX כנקראו: SELECT, כי רק במצב קריאה וכתיבה אפשר לשנות דגלים.
טעויות נפוצות ובדיקה עצמית: דואר ו-IMAP
טעויות נפוצות
- IMAP הוא הפרוטוקול ששולח את ההודעות שלי. שליחה היא העבודה של SMTP. IMAP קורא מהתיבה שבשרת.
- IMAP מוריד את הדואר אל המכשיר ומוחק אותו מהשרת. זה התיאור של POP3 במצב הרגיל. ב-IMAP ההודעות נשארות בשרת.
- ב-IMAP לכל מכשיר יש עותק פרטי, ומה שעושים באחד לא משפיע על השני. השרת הוא מקור האמת היחיד, וכל שינוי מגיע לכל המכשירים.
- IMAP רץ מעל UDP ומוגבל לתיקייה אחת. IMAP רץ מעל TCP ומנהל תיקיות רבות בשרת.
- IMAP מוצפן מאזין בפורט 995, או בפורט 22. 995 שייך ל-POP3 המוצפן, ו-22 שייך ל-SSH. IMAPS משתמש בפורט 993.
- אם מעבירים את השרת לפורט לא מוכר או מאריכים את הסיסמה, התעבורה מוגנת. שום דבר מאלה לא מצפין. רק TLS או מנהרת SSH מצפינים.
- ב-PLAIN הסיסמה מוצפנת ב-Base64. Base64 הוא קידוד הפיך. בלי TLS הסיסמה נקראת ישר מהלכידה.
- EXAMINE פותחת תיבה לקריאה ולכתיבה, או מחזירה את רשימת התיבות. EXAMINE פותחת תיבה אחת לקריאה בלבד. את רשימת התיבות מחזירה LIST.
- IDLE היא ההגדרה של תדירות ה-polling. IDLE מבטלת את הצורך ב-polling: השרת מודיע בעצמו על שינויים.
בדקו את עצמכם
שרת עונה NO על LOGIN, ובתשובת CAPABILITY שלו מופיע LOGINDISABLED. מה הלקוח צריך לעשות כדי להיכנס?
לשלוח STARTTLS, לחכות שהחיבור יוצפן, ורק אז לשלוח שוב LOGIN. ההזדהות חסומה רק כל עוד החיבור גלוי.
חומת האש של מלון חוסמת את פורט 993 אבל מעבירה את 143. האם אפשר עדיין לקרוא דואר בחיבור מוצפן?
כן, אם השרת מציע STARTTLS: מתחברים ל-143 ומשדרגים את החיבור. אם לא, מנהרת SSH אל השרת היא האפשרות הנוספת.
לקוח רוצה להציג את רשימת התיקיות, ואז לעבור על אחת מהן בלי שום אפשרות לשנות בה דבר. אילו שתי פקודות הוא שולח, ובאיזה סדר?
קודם LIST, שמחזירה את רשימת התיבות, ואז EXAMINE על התיקייה הנבחרת. SELECT הייתה פותחת אותה לקריאה ולכתיבה.
במה שונה NOOP מ-IDLE?
NOOP לא עושה כלום חוץ מלתת לשרת הזדמנות לדווח, ולכן לקוח שנשען עליה שולח אותה שוב ושוב (polling). ב-IDLE הערוץ נשאר פתוח והשרת מודיע מיוזמתו.
Telnet: גישה מרחוק בטקסט גלוי
מה Telnet עושה, ולמה הוא לא בטוח
נניח שאתם צריכים להריץ פקודות על נתב שנמצא בחדר שרתים בקומה אחרת. Telnet פותח לכם חלון טקסט שמחובר אליו: אחרי שם משתמש וסיסמה, כל מה שתקלידו יתבצע שם ולא אצלכם. מתחת לפני השטח זה חיבור TCP לפורט 23.
דמיינו שמקליטים ב-Wireshark התחברות כזו לנתב ופותחים Follow TCP Stream. על המסך מופיעים, כטקסט שאפשר לקרוא, שם המשתמש, הסיסמה, כל פקודה שהוקלדה וכל פלט שחזר. אין שם שום שכבה שצריך לשבור, כי Telnet לא מצפין שום חלק מהשיחה, ולכן ארגונים החליפו אותו ב-SSH.
סביב החולשה הזו נפוצות טענות שגויות רבות. הנה הן, כולן מול העובדות:
| טענה על Telnet | נכון? | העובדה |
|---|---|---|
| מצפין לפחות את פרטי הכניסה | לא | אין שום הצפנה, גם לא לשם המשתמש או לסיסמה |
| מצפין באלגוריתם ישן שאפשר לפצח | לא | אין אלגוריתם בכלל, ואין גם מפתח שהוגדר מראש |
| דוחס את התעבורה | לא | אין דחיסה |
| שומר יומן מוצפן בצד השרת | לא | אין רכיב כזה בפרוטוקול |
| מגביל סיסמה לשמונה תווים | לא | אין מגבלה כזו, וזו לא הסיבה שהוא מסוכן |
| מגביל את מספר המשתמשים המחוברים | לא | זו לא הבעיה שלו |
| רץ מעל UDP | לא | הוא רץ מעל TCP, בפורט 23 |
| לא תואם IPv6 | לא | התאימות לא קשורה לחולשה |
| אם חומת האש מעבירה אותו, הוא בטוח | לא | חומת אש לא מצפינה, והסיסמה נשארת גלויה |
בלי פורט, הפקודה פונה לפורט ברירת המחדל, 23:
telnet 10.20.30.40עם פורט, הלקוח פונה בדיוק אליו ולא חוזר ל-23:
telnet 10.20.30.40 8443מי שמנסה להריץ את הפקודה בווינדוס עלול לגלות שהמערכת לא מכירה אותה: הלקוח מגיע שם כרכיב רשות, ולפני השימוש הראשון מפעילים אותו ידנית.
חזרה לתוכן הענייניםtelnet host port: בודקים אם פורט TCP פתוח
לפקודה telnet host port יש שלוש תוצאות אפשריות, וכל אחת מספרת משהו אחר על היעד:
| מה מופיע במסך | פירוש |
|---|---|
Connected to ..., ואחריו מסך שקט עם סמן מהבהב | החיבור קם. שירות מאזין בפורט ומחכה שתקלידו משהו. |
Connection refused או Connect failed | הפורט סגור: היעד החזיר RST, כי אף שירות לא מאזין בו. |
| שום תשובה, והפקודה תקועה עד שנגמר זמן ההמתנה | בדרך כלל חומת אש שמסננת את הפורט וזורקת את החבילות בשקט. |
ההסבר: כשנותנים ללקוח מספר פורט, הוא בכלל לא מנסה לדבר בפרוטוקול Telnet, אלא רק פותח חיבור TCP גולמי.
Connected אומר ש-SYN, SYN-ACK ו-ACK הושלמו, כלומר משהו ביעד מאזין והדרך אליו פתוחה. RST הוא סירוב מפורש, ושקט אומר שהחבילות נעלמו בדרך.
הנה סירוב אמיתי, ממכונה שאין בה אף שירות בפורט 2525. בווינדוס הנוסח יהיה Connect failed, אבל המשמעות זהה:
telnet 127.0.0.1 2525Trying 127.0.0.1...
telnet: Unable to connect to remote host: Connection refusedהמסך השקט ריק כי הצד השני מחכה שתתחילו, ואין כאן שום שלב של הזדהות שנכשל.
חיבור שנסגר נראה אחרת: telnet כותב Connection closed by foreign host. ומחזיר את שורת הפקודה, כמו בסוף הדוגמאות בחלק הבא.
יש שירותים שלא מחכים, אלא פותחים בעצמם בשורת ברכה שנקראת banner. מה מקבלים כשמכוונים telnet לפורט 22 של מכונה עם OpenSSH?
$ telnet 172.16.5.9 22
Trying 172.16.5.9...
Connected to 172.16.5.9.
Escape character is '^]'.
SSH-2.0-OpenSSH_8.9p1 Ubuntu-3ubuntu0.11| מה אפשר להסיק מהפלט | מה אי אפשר להסיק |
|---|---|
| חיבור TCP לפורט 22 הוקם, כי לחיצת היד הסתיימה ורק אחריה השרת כתב | שנפתח סשן SSH: telnet לא מדבר את הפרוטוקול |
| שרת SSH מסוג OpenSSH מאזין בפורט, וזו שורת הפתיחה שלו | שהייתה הצפנה או הזדהות כלשהי |
| השירות אינו שרת Telnet, שהיה מבקש להזין שם משתמש | שהשירות רץ בפורט 23 או ש-telnet עבר לשם |
תרחיש 7: האפליקציה לא מגיעה למסד הנתונים
אפליקציה בשרת web01 מדווחת שאינה מצליחה להתחבר למסד הנתונים ב-10.8.0.12, פורט 5432. מריצים מ-web01 את telnet 10.8.0.12 5432. מה עושים עם כל תוצאה?
| מה התקבל | האבחנה | הצעד הבא |
|---|---|---|
| Connected ומסך שקט | הרשת תקינה ומסד הנתונים מאזין. telnet לא בדק סיסמה או שם מסד | לחפש בהגדרות האפליקציה, למשל בפרטי ההתחברות |
| Connection refused | היעד ענה, אבל אף שירות לא מאזין בפורט | לבדוק אם השירות כבוי, או מאזין בפורט אחר |
| תקוע עד שנגמר הזמן | החבילות נזרקות בדרך, כנראה בחומת אש | לבדוק את חוקי חומת האש בין web01 למסד הנתונים |
אותה פקודה, שלוש תוצאות שונות, ובכל אחת מחפשים את התקלה במקום אחר.
שיחה ידנית עם פרוטוקול טקסטואלי
בדרך כלל הדפדפן או תוכנת הדואר כותבים בשבילכם את הפקודות. עם telnet אתם נכנסים לנעליים שלהם, וזה אפשרי כי HTTP בפורט 80 ו-SMTP בפורט 25 מדברים בשורות טקסט שאדם מסוגל לכתוב ולקרוא.
כך רואים במו עיניים מה השרת מקבל ומה הוא מחזיר, וזה כלי ותיק לניפוי תקלות. הנה בקשת GET שנכתבה ביד מול שרת אינטרנט קטן שרץ במחשב (הקלט מגיע מ-printf במקום מהמקלדת):
{ printf 'GET /index.html HTTP/1.0\n\n'; sleep 1; } | telnet 127.0.0.1 8088Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/3.10.12
Date: Sat, 07 Nov 2026 18:58:31 GMT
Content-type: text/html
Content-Length: 16
Last-Modified: Sat, 07 Nov 2026 18:58:30 GMT
<h1>pantry</h1>
Connection closed by foreign host.ומה קורה כשמקלידים שטות? telnet מעביר אותה לשרת בלי שום בדיקה, והשרת הוא שמחזיר שגיאה:
{ printf 'GIMME /index.html HTTP/1.0\n\n'; sleep 1; } | telnet 127.0.0.1 8088 2>&1 | head -4Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
HTTP/1.0 501 Unsupported method ('GIMME')ובשרת דואר, השורות שאתם מקלידים והתשובות של השרת מתחלפות לסירוגין:
$ telnet mx.office.example 25
Trying 10.20.30.25...
Connected to mx.office.example.
Escape character is '^]'.
220 mx.office.example ESMTP ready
EHLO laptop.lab (typed by you)
250-mx.office.example
250-8BITMIME
250 HELP
QUIT (typed by you)
221 Bye
Connection closed by foreign host.שתי הדוגמאות מראות ש-telnet הוא צינור שקוף. מה שהקלדתם יוצא כמו שהוא, בלי תרגום ל-SSH, בלי הצפנה של הדואר ובלי בדיקה שהבקשה תקינה. אותו צינור שקוף גם לכל מאזין, ולכן לא מקלידים בו סיסמה או מידע רגיש.
חזרה לתוכן הענייניםמה נשאר מ-Telnet היום
אם תראו היום מישהו מקליד telnet, כמעט תמיד הוא עושה אחד משני דברים: בודק מהר אם שרת מקבל חיבורים בפורט TCP מסוים, או משוחח ידנית עם שירות טקסטואלי כדי לאתר תקלה. ניהול שרתים כבר עבר ל-SSH, שתפס את מקומו של Telnet ולא להפך.
| משימה | הכלי המתאים | האם telnet עושה אותה? |
|---|---|---|
| לבדוק אם פורט TCP מאזין | telnet host port | כן |
| לראות את הנתבים שבדרך ליעד | traceroute | לא |
| לתרגם שם לכתובת IP | DNS | לא |
| לבדוק אם פורט UDP פתוח | כלי ייעודי ל-UDP | לא, ב-UDP אין חיבור לפתוח |
| לנהל שרת מרוחק בצורה מוצפנת | SSH | לא, Telnet לא מצפין |
טעויות נפוצות ובדיקה עצמית: Telnet
טעויות נפוצות
- Telnet מצפין לפחות את שם המשתמש. אין בו הצפנה בכלל, לא לשם המשתמש, לא לסיסמה ולא לפקודות.
- Telnet רץ מעל UDP. הוא רץ מעל TCP בפורט 23, ובדיקת פורט בעזרתו מתאימה רק לפורטי TCP.
telnet host 443מתעלם מהמספר ומתחבר ל-23. כשמציינים פורט, הלקוח מתחבר אליו. 23 הוא רק ברירת המחדל כשלא מציינים דבר.- מסך שקט אחרי telnet מעיד על חסימה בחומת אש או על הזדהות שנכשלה. מסך שקט וסמן מהבהב הם חיבור שהצליח. חסימה נראית כהמתנה ארוכה או כהודעת שגיאה.
- קיבלתי banner של SSH, אז telnet פתח סשן SSH מוצפן. נפתח רק חיבור TCP, והשרת שלח את שורת הפתיחה שלו. telnet לא מדבר SSH.
- אם telnet לפורט מסוים הצליח, המכונה בוודאי עונה ל-ping. אלה שתי בדיקות נפרדות, ואחת יכולה להצליח כשהשנייה נכשלת.
- כדי להתחבר לפורט ברירת המחדל כותבים
ssh -t host telnet,telnet://host:443אוftp host 23. הפקודה היא פשוטtelnet host. - Telnet טוב לעבודת ניהול יומיומית, כי הוא זריז ודוחס את התעבורה. אין בו דחיסה, ובעיקר אין בו הצפנה, ולכן הוא לא מתאים לניהול.
בדקו את עצמכם
אחרי telnet 10.8.0.12 5432 הופיע Connected, אבל האפליקציה עדיין נכשלת. האם telnet אישר שהסיסמה של האפליקציה נכונה?
לא. telnet רק הקים חיבור TCP, ולכן הוכיח שמשהו מאזין בפורט ושהדרך פתוחה. בסיסמה ובפרוטוקול של מסד הנתונים הוא לא נגע.
צוות רוצה לוודא ששרת זמן (NTP, פורט UDP 123) עונה, ומציע להריץ telnet ntp1 123. מה הבעיה בהצעה?
telnet פותח רק חיבורי TCP, וב-UDP אין חיבור שאפשר להקים. התוצאה לא תגיד דבר על השירות.
מיד אחרי Connected הופיעה השורה Connection closed by foreign host. וחזרה שורת הפקודה. במה זה שונה ממסך שקט?
כאן הצד השני קיבל את החיבור וסגר אותו. במסך שקט החיבור עדיין פתוח, והשירות ממתין לקלט.
SSH: ערוץ מוצפן, לחיצת יד וזהות השרת
SSH: מה הוא ומה עושים בו
קחו את הלכידה הדמיונית של Telnet מהחלק הקודם, שבה שם המשתמש והסיסמה נקראו כמו מכתב פתוח, ודמיינו את אותה עבודה ב-SSH. בתחילת הלכידה עדיין אפשר לקרוא משהו: שורות הזיהוי של שני הצדדים, את רשימות האלגוריתמים שהם מציעים זה לזה ואת הודעות החלפת המפתחות. מהרגע שההחלפה מסתיימת, מופיעים רק בתים חסרי משמעות, עד סוף החיבור.
SSH, קיצור של Secure Shell, נולד בדיוק כדי להחליף את Telnet: גישה לשורת הפקודה של מחשב מרוחק, מעל TCP בפורט 22. ההצפנה שלו מכסה את החיבור כולו, ההזדהות, הסיסמה, הפקודות והפלט, ולא רק את שלב הכניסה. הוא עובד גם על פני האינטרנט הציבורי ולא רק ברשת מקומית, ואין לו קשר לניהול תיבות דואר.
ssh maya@build.lab.internal| Telnet | SSH | |
|---|---|---|
| פורט | 23 | 22 |
| הצפנה | אין | כל החיבור, מקצה לקצה |
| מה רואה מאזין | הכול, כולל הסיסמה | את שורות הזיהוי, את בחירת האלגוריתמים ואת החלפת המפתחות בתחילת החיבור, וגם כתובות, פורטים, נפח ותזמון. כל מה שאחרי החלפת המפתחות, כולל הסיסמה, הפקודות והפלט, מוצפן |
| מהירות ומספר חיבורים | לא אלה היתרון של SSH: הוא לא מהיר יותר ולא מרשה יותר חיבורים בו זמנית | היתרון שלו הוא אבטחה |
| יכולות נוספות | אין | העברת קבצים מוצפנת (SCP, SFTP), מנהרות ו-Port Forwarding, תוכנות גרפיות מרחוק (X11 Forwarding), הזדהות בזוג מפתחות במקום סיסמה |
כל אחת מהיכולות הנוספות מקבלת חלק משלה בהמשך הפרק.
חזרה לתוכן הענייניםמה קורה בלחיצת היד של SSH
עוד לפני שמופיעה שורת הפקודה, הלקוח והשרת עוברים שלב תיאום שנקרא Handshake:
- כל צד שולח שורת זיהוי (banner), למשל
SSH-2.0-OpenSSH_8.9p1, בלי הצפנה. - הצדדים מסכמים באילו אלגוריתמים ישתמשו (הודעת KEXINIT). גם זה עובר גלוי, ומאזין יכול לקרוא בו שמות כמו
curve25519-sha256ו-ssh-ed25519. - מתבצעת החלפת מפתחות, והשרת חותם עליה במפתח המארח (Host Key) שלו. החתימה היא ההוכחה שהוא אכן השרת שהוא טוען להיות. גם ההודעות של שלב זה עוברות לפני שיש הצפנה, אבל מתוך מה שגלוי בהן אי אפשר לחשב את המפתחות שייווצרו.
- ההחלפה נחתמת בהודעה NEWKEYS, ומכאן נוצר ערוץ מוצפן: כל מה שעובר אחריה מוצפן.
- רק בתוך הערוץ הזה המשתמש מזדהה, בסיסמה או במפתח פרטי.
עכשיו הסתכלו על זה מהצד של המאזין: כדי לקרוא את הסשן הוא צריך את מפתחות ההפעלה (session keys) שמצפינים אותו. אלה נגזרים בשלב 3, בתחילת כל חיבור, ולא עוברים בקו.
אין להם גם קשר לזוג המפתחות שבו המשתמש מזדהה, כך שגם מי שגנב בעבר מפתח של משתמש לא מקבל מזה את מפתחות ההפעלה.
והסיסמה? היא נשלחת רק בשלב 5, לתוך ערוץ שמוצפן כבר מאז שלב 4. ובכל השלבים האלה לא מופיעה כתובת MAC של אף צד, כי היא לא חלק מהתהליך.
שלב 3 מעלה שאלה: איך הלקוח יודע שהחתימה שייכת לשרת הנכון? כאן SSH הולך בדרך שונה מזו של HTTPS:
| HTTPS | SSH, כברירת מחדל | |
|---|---|---|
| מי מעיד על זהות השרת | רשות אישורים (CA) שחתמה על התעודה של האתר | הלקוח עצמו, שזוכר את מפתח המארח |
| איפה נשמר מה שסומכים עליו | רשימת רשויות שמותקנת בדפדפן | הקובץ known_hosts אצל הלקוח |
מפתח המארח והקובץ known_hosts
השרת מזדהה בעזרת זוג מפתחות שנוצר עבורו, בדרך כלל בהתקנה, ונשמר אצלו. את החצי הפרטי הוא לא מראה לאף אחד, ואת החצי הציבורי, מפתח המארח (Host Key), הוא מציג בכל חיבור כמו תעודת זהות.
טביעת אצבע (fingerprint) היא תקציר קצר של המפתח הזה, שנוח להשוות בעיניים. כך היא נראית למפתח Ed25519 שיצרנו לשרת בדיקה:
ssh-keygen -lf hostkey.pub256 SHA256:CwMQHC+lS/HpYLsNaggYnzDlVNfsQzfpJPMBIDueMVY no comment (ED25519)אין לכם שום רישום של שרת שמעולם לא התחברתם אליו, ולכן בפעם הראשונה הלקוח מציג את טביעת האצבע ושואל אם לסמוך עליה:
The authenticity of host 'build.lab.internal (10.8.0.30)' can't be established.
ED25519 key fingerprint is SHA256:CwMQHC+lS/HpYLsNaggYnzDlVNfsQzfpJPMBIDueMVY.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])?כשעונים yes, הלקוח רושם את המפתח בקובץ ~/.ssh/known_hosts במחשב שלכם, כלומר אצל הלקוח. מכאן שם המודל: trust on first use, אמון שניתן במפגש הראשון. הצעד הנכון לפני yes הוא להשוות את טביעת האצבע לזו שמנהל השרת פרסם, למשל כזו שהופקה בשרת עצמו בפקודה שלמעלה.
מהחיבור השני ואילך הלקוח כבר לא שואל, אלא בודק: הוא מחפש את השרת ב-known_hosts ומשווה את המפתח שהוצג לרשום. כשאין התאמה, הוא עוצר בהודעה בולטת ולא מתחבר, עד שהשורה הישנה נמחקת או מתעדכנת:
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@את השורה הישנה מסירים בפקודה ssh-keygen -R. בדוגמה הבאה בודקים קודם שהשרת רשום (-F), ואז מוחקים אותו. הדגל -f מכוון לקובץ known_hosts מסוים, ובלעדיו הפקודה עובדת על ~/.ssh/known_hosts:
ssh-keygen -F build.lab.internal -f known_hosts
ssh-keygen -R build.lab.internal -f known_hosts# Host build.lab.internal found: line 1
build.lab.internal ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIPB5Ew4BOM3tffuB7eRd3g3d1r+Pux1g5JN9yxYQDLui
# Host build.lab.internal found: line 1
known_hosts updated.
Original contents retained as known_hosts.oldהאזהרה לא אומרת מה קרה, רק שהמפתח שונה. מיינו את האירועים הבאים לפי השאלה אם הם מסוגלים לגרום לה:
| אירוע | יגרום לאזהרה? | למה |
|---|---|---|
| השרת הותקן מחדש ויצר מפתח חדש | כן | המפתח השמור כבר לא תואם. סיבה לגיטימית |
| מישהו באמצע הדרך מתחזה לשרת (Man-in-the-Middle) | כן | המתחזה מציג מפתח אחר. הסיבה המסוכנת |
| השרת אותחל | לא | אתחול לא מייצר מפתח מארח חדש |
| תוקף הסיסמה של המשתמש פג | לא | הלקוח לא מאמת את השרת בעזרת סיסמה, וזהות השרת נבדקת לפני כל הזדהות |
| המפתח של המשתמש הוסר מ-authorized_keys | לא | זה נוגע להזדהות המשתמש, שמגיעה אחרי אימות השרת ותיכשל בהודעה אחרת |
מכיוון ששתי השורות הראשונות נראות ללקוח בדיוק אותו דבר, ההחלטה תלויה במידע מבחוץ: שואלים את מי שמנהל את השרת אם המפתח באמת הוחלף, ורק אז מוחקים או מעדכנים את השורה.
כדאי לנסח לעצמכם במדויק מה known_hosts עושה ומה לא:
| known_hosts עושה | known_hosts לא עושה |
|---|---|
| מאמת בפני הלקוח שהשרת הוא אותו שרת | לא מאמת את המשתמש מול השרת |
| שומר מפתחות ציבוריים של שרתים | לא שומר את המפתח הפרטי של המשתמש |
| מתריע כשמפתח של שרת מוכר משתנה פתאום | לא מבטל סיסמאות ולא מאיץ את ההתחברות |
| יושב אצל הלקוח | לא קובע אילו משתמשים רשאים להתחבר, כי את זה מגדירים בשרת |
עכשיו מנקודת המבט של התוקף. נניח שהוא יושב ברשת של בית קפה, מיירט את החיבור שלכם ומעמיד פנים שהוא השרת. כדי לעבור את שלב 3 של לחיצת היד הוא צריך לחתום על החלפת המפתחות במפתח הפרטי של המארח, ואת המפתח הזה אין לו.
הוא יכול להציג רק מפתח משלו, והלקוח משווה אותו ל-known_hosts ומגלה זר. כך known_hosts מונע Man-in-the-Middle. הבדיקה עונה רק על השאלה אם זה השרת הנכון: הזדהות המשתמש, בסיסמה או במפתח, עדיין נדרשת אחריה, וגם התאמה בין גרסאות הפרוטוקול היא עניין אחר.
תרחיש 8: האזהרה שהמנהל לא הסביר
רון עובד מבית מלון ומתחבר, כמו בכל בוקר, לשרת build.lab.internal. הפעם ssh עוצר עם האזהרה על שינוי בזהות המארח. בדחיפות של הבוקר הוא כבר מקליד ssh-keygen -R, אבל עוצר ושולח הודעה לצוות התשתיות.
התשובה: אף אחד לא נגע בשרת, לא התקנה מחדש ולא החלפת מפתח. מכאן שהסבר התמים נפסל, ונשאר האפשרי המסוכן: מישהו ברשת של המלון מציג את עצמו כשרת.
רון לא מוחק את השורה ולא מקליד סיסמה. הוא מתנתק, מדווח לצוות האבטחה, ומתחבר מאוחר יותר מרשת אחרת, שם המפתח שוב תואם. אילו היה מוחק את השורה ומאשר את המפתח החדש, הוא היה מוסר את הסיסמה שלו ישר למתחזה.
טעויות נפוצות ובדיקה עצמית: זהות השרת ב-SSH
טעויות נפוצות
- known_hosts מחזיק את המפתח הפרטי שלי. הוא מחזיק מפתחות ציבוריים של השרתים שהתחברתם אליהם.
- ב-known_hosts מגדירים מי מורשה להיכנס לשרת. הרשאות כניסה מוגדרות בצד השרת. known_hosts נמצא אצל הלקוח ועוסק בזהות השרת.
- מפתח המארח מוכיח לשרת מי המשתמש. הכיוון הפוך: הוא מוכיח ללקוח מי השרת.
- בזכות מפתח השרת אפשר לוותר על הסיסמה כבר בחיבור הראשון. אימות השרת לא מחליף את הזדהות המשתמש, וזו מגיעה אחריו, בסיסמה או במפתח פרטי.
- בלחיצת היד הלקוח שולח קודם את הסיסמה, ורק אחר כך מתחילה ההצפנה. קודם מסכמים אלגוריתמים, מחליפים מפתחות ובונים ערוץ מוצפן, ורק אז מזדהים.
- בלחיצת היד השרת מציג תעודה של רשות אישורים, והלקוח מזדהה בכתובת ה-MAC שלו. כברירת מחדל SSH נשען על מפתח מארח ועל known_hosts, ו-MAC לא מעורב בכלל.
- אתחול של השרת מייצר מפתח מארח חדש. המפתח שמור בשרת ושורד אתחולים. רק התקנה מחדש או החלפה יזומה משנים אותו.
- מפתח מארח שהשתנה אומר בוודאות שהשרת נפרץ. התקנה מחדש היא הסבר לגיטימי ושכיח, ולכן מבררים מול המנהל לפני שממשיכים.
בדקו את עצמכם
קיבלתם מחשב נייד חדש, ו-ssh לשרת שאתם מכירים שנים שואל שוב על טביעת אצבע. האם השרת השתנה?
לא בהכרח. known_hosts נמצא אצל הלקוח, ובמחשב החדש הוא ריק, ולכן כל שרת נראה לו כחיבור ראשון. משווים את טביעת האצבע לזו שהמנהל פרסם.
עמית מציע למחוק את known_hosts בכל פעם שמופיעה אזהרה, כי היא מעצבנת. מה מאבדים?
את ההגנה מפני Man-in-the-Middle: כל חיבור הופך לחיבור ראשון, ואין עוד דרך לזהות מתחזה שמציג מפתח אחר.
עד הרגע שבו הסיסמה נשלחת, מה כבר קרה בלחיצת היד?
הצדדים החליפו שורות זיהוי, סיכמו אלגוריתמים, ביצעו החלפת מפתחות שהשרת חתם עליה במפתח המארח, ובנו ערוץ מוצפן. הסיסמה נכנסת לתוכו.
האם מפתחות ההפעלה שמצפינים את הסשן הם זוג המפתחות שבו המשתמש מזדהה?
לא. מפתחות ההפעלה מוסכמים בתחילת החיבור ונפרדים לגמרי מזוג המפתחות של המשתמש.
SSH: הזדהות בזוג מפתחות
סיסמה או זוג מפתחות: שתי דרכים להוכיח זהות
אחרי שהערוץ המוצפן קם, שרת ה-SSH עדיין צריך לוודא שמי שמתחבר הוא בעל החשבון. יש לכך שתי דרכים עיקריות: להקליד סיסמה, או להוכיח שבידיכם מפתח פרטי מתוך זוג מפתחות (key pair).
זוג מפתחות הוא שני קבצים שנוצרו יחד וקשורים זה לזה בקשר מתמטי. דמיינו דוגמת חתימה שהפקדתם בבנק: הבנק מחזיק את הדוגמה ומשווה אליה כל צ'ק, אבל אף פעם לא צריך את היד שלכם כדי לבדוק. המפתח הציבורי הוא הדוגמה, והמפתח הפרטי הוא היד שחותמת.
- המפתח הפרטי הוא הסוד. הוא נשמר במחשב הלקוח ולא נשלח לאף שרת, אף פעם.
- המפתח הציבורי אינו סוד. מותר לתת אותו לכל אחד, ואותו בדיוק מעתיקים לשרת שאליו רוצים להתחבר.
זו הדרך המקובלת להתחבר ב-SSH בלי להקליד סיסמה. את הזוג מייצרים בצד הלקוח, ורק החצי הציבורי עובר לשרת.
known_hosts לא שייך לכאן: הקובץ הזה עוזר ללקוח לזהות את השרת, ואינו פוטר את המשתמש מהזדהות.ssh-keygen מייצר את הזוג, ssh-copy-id מתקין את החצי הציבורי
את הזוג מייצרים בפקודה ssh-keygen, והדגל -t בוחר את סוג המפתח. ההרצה הרגילה היא ssh-keygen -t ed25519, והיא שומרת את שני הקבצים בתיקייה ~/.ssh של המשתמש בשמות id_ed25519 ו-id_ed25519.pub.
בניסוי שלמטה הפנינו את הקבצים לתיקיית ניסוי בשם lab בעזרת -f, ו--N "" מוותר על משפט סיסמה למפתח, כדי שההרצה לא תעצור לשאלות:
mkdir -p lab && chmod 700 lab
ssh-keygen -q -t ed25519 -N "" -C noa@laptop -f lab/id_ed25519
ls lab
ssh-keygen -l -f lab/id_ed25519.pub # size, fingerprint and comment of the public key
cut -d" " -f1,3 lab/id_ed25519.pub # key type and comment of the public keyid_ed25519 id_ed25519.pub
256 SHA256:lthuZy/W4qWFnQ2WkF6R96rrJagHaaFNJaDoV3HJsBY noa@laptop (ED25519)
ssh-ed25519 noa@laptopשני קבצים נוצרו מהפקודה: הקובץ בלי סיומת הוא הפרטי, ואותו לא מציגים לאף אחד, והקובץ עם .pub הוא הציבורי, שורה אחת שמתחילה בסוג המפתח. ssh-keygen -l קורא את הציבורי ומציג את גודל המפתח (256 ביט), את טביעת האצבע (fingerprint) שלו ואת ההערה. בטבלה מופיעים גם שני קבצים נוספים שאינם תוצר של ssh-keygen ושכדאי לא לבלבל ביניהם:
| קובץ | מה יש בו | איפה הוא יושב |
|---|---|---|
id_ed25519 | המפתח הפרטי. סודי, ואינו יוצא מהלקוח | במחשב הלקוח |
id_ed25519.pub | המפתח הציבורי. זה מה שמתקינים בשרת | נוצר בלקוח ומועתק לשרת |
authorized_keys | המפתחות הציבוריים של כל מי שמורשה להיכנס לחשבון, מפתח אחד בכל שורה | בשרת, בתיקייה ~/.ssh של החשבון |
known_hosts | המפתחות הציבוריים של השרתים שהלקוח כבר התחבר אליהם | במחשב הלקוח |
ההתקנה פירושה להוסיף את תוכן id_ed25519.pub כשורה חדשה ב-authorized_keys של החשבון בשרת היעד. אפשר לעשות את זה ביד, אבל הכלי ssh-copy-id עושה את כל העבודה בפקודה אחת:
ssh-copy-id -i ~/.ssh/id_ed25519.pub omer@backup.example.net- הוא מתחבר לשרת בחיבור SSH רגיל, ובדרך כלל זו הפעם האחרונה שתתבקשו להקליד את הסיסמה.
- הוא מוסיף את המפתח הציבורי לסוף הקובץ
~/.ssh/authorized_keysשל החשבון בשרת. - הוא מוודא שלתיקייה ולקובץ יש הרשאות (permissions) מתאימות, כי שרת SSH מתעלם מקובץ מפתחות שאחרים יכולים לכתוב אליו.
היתרון מול עריכה ידנית הוא שלא צריך להיכנס לשרת, לפתוח עורך ולהדביק שורה ארוכה. כך נחסכות שגיאות העתקה וטעויות הרשאה שמכשילות את ההתחברות בשקט.
חשוב לדעת גם מה הכלי לא עושה. הוא מעביר רק את החצי הציבורי ולעולם לא את הפרטי, הוא לא מייצר מפתחות (זה התפקיד של ssh-keygen בלקוח), והוא לא כותב שום דבר ל-known_hosts.
known_hosts.מה עובר ברשת כשמתחברים במפתח
- הלקוח מודיע לשרת באיזה מפתח ציבורי הוא רוצה להשתמש.
- השרת מוצא את המפתח הזה ב-
authorized_keysשל החשבון ומציב אתגר (challenge): נתון חד פעמי שהלקוח צריך לחתום עליו. בפרוטוקול עצמו האתגר נגזר ממזהה הסשן שנקבע בלחיצת היד, ולכן הוא שונה בכל חיבור. - הלקוח חותם על האתגר בעזרת המפתח הפרטי ושולח רק את החתימה.
- השרת בודק את החתימה בעזרת המפתח הציבורי שכבר שמור אצלו. אם היא תקינה, המשתמש בפנים.
אפשר לראות את העיקרון הזה בעבודה בעזרת יכולת החתימה של ssh-keygen (הדגל -Y, זמין מ-OpenSSH 8.1). זה לא פרוטוקול ההתחברות עצמו, אבל זו אותה פעולה: חתימה במפתח הפרטי ובדיקה במפתח הציבורי בלבד.
# server side: it holds only the public half
echo "noa@laptop $(cut -d" " -f1,2 lab/id_ed25519.pub)" > allowed_signers
# server: a fresh random challenge
echo "nonce 5d81e0c2" > challenge.txt
# client: sign the challenge with the private key (the key file stays here)
ssh-keygen -q -Y sign -f lab/id_ed25519 -n login challenge.txt
# server: check the signature using only the public key
ssh-keygen -Y verify -f allowed_signers -I noa@laptop -n login -s challenge.txt.sig < challenge.txt
# replay: the old signature against a new challenge
echo "nonce 9a04f7b3" | ssh-keygen -Y verify -f allowed_signers -I noa@laptop -n login -s challenge.txt.sigGood "login" signature for noa@laptop with ED25519 key SHA256:lthuZy/W4qWFnQ2WkF6R96rrJagHaaFNJaDoV3HJsBY
Signature verification failed: incorrect signature
Could not verify signature.הקובץ allowed_signers ממלא כאן את התפקיד של authorized_keys: יש בו רק את המפתח הציבורי, והוא הספיק כדי לאשר את החתימה. הניסיון השני נכשל כי החתימה שייכת לאתגר הקודם, ולכן מי שהקליט חתימה ישנה לא יכול להשתמש בה מול אתגר חדש.
המפתח הפרטי עצמו לא חוצה את הרשת ולא נשמר בשרת. לכן אין סיסמה קבועה שתוקף יכול לנחש בניסיונות חוזרים או לשלוף מהשרת אחרי פריצה, וההתחברות כבר לא נשענת על סיסמה בלבד.
התוצאה היא הגנה טובה בהרבה מפני ניחוש סיסמאות בכוח (Brute Force), ובנוסף נוחות: סקריפטים ומשימות אוטומטיות מתחברים בלי שמישהו יקליד סיסמה.
מה השיטה לא נותנת: היא לא חוסכת רוחב פס ולא מאיצה את השרת, היא לא פוטרת מהצורך בחשבון משתמש בשרת, והיא לא עובדת בכלל אם המפתח הציבורי לא הותקן קודם ב-authorized_keys.
Ed25519 מול RSA
בדגל -t של ssh-keygen בוחרים בין סוגי מפתחות, והשניים הנפוצים הם RSA ו-Ed25519. Ed25519 בנוי על קריפטוגרפיה של עקומות אליפטיות, ולכן מפתח של כ-256 ביט מספיק לו כדי להגיע לרמת אבטחה מאותו סדר גודל כמו מפתח RSA של אלפי ביטים, למשל RSA-4096.
ההבדל באורך ניכר כבר בקובץ הציבורי. נוסיף לתיקיית הניסוי מפתח RSA-4096 ונשווה גדלים:
ssh-keygen -q -t rsa -b 4096 -N "" -C noa@laptop -f lab/id_rsa
wc -c lab/id_ed25519.pub lab/id_rsa.pub # size in bytes 92 lab/id_ed25519.pub
736 lab/id_rsa.pub
828 totalמעבר לאורך, פעולת החתימה ב-Ed25519 מהירה יותר וצורכת פחות חישוב. בסיכום, Ed25519 מנצח באורך המפתח ובמהירות החתימה, ונשאר ברמת אבטחה שקולה ל-RSA-4096.
הכללים של זוג המפתחות לא משתנים עם הסוג. גם ב-Ed25519 החצי הפרטי לא יוצא מהלקוח, ובשרת מותקן רק החצי הציבורי.
תרחיש 9: שרת גיבויים בלי הקלדת סיסמה
עומר מריץ כל לילה סקריפט שמעביר קבצים לשרת הגיבויים, ונמאס לו להקליד סיסמה. הוא עובר להזדהות במפתח.
- במחשב שלו הוא מריץ
ssh-keygen -t ed25519. נוצריםid_ed25519, שנשאר אצלו, ו-id_ed25519.pub, שמיועד לשרת. - הוא מריץ
ssh-copy-id omer@backup.example.net, מקליד את הסיסמה פעם אחרונה, והכלי מוסיף את הציבורי ל-authorized_keysבשרת ומסדר את ההרשאות. - מעכשיו
ssh omer@backup.example.netנכנס בלי סיסמה: השרת שולח אתגר, הלקוח חותם במפתח הפרטי, והשרת מאמת בעזרת הציבורי.
הקובץ הפרטי לא עזב את המחשב של עומר בשום שלב. וכל מה שהשרת היה צריך הוא השורה שנוספה ל-authorized_keys, בלי שום למידה שלו בחיבור הראשון.
טעויות נפוצות
- ל-authorized_keys בשרת מוסיפים את הקובץ id_ed25519. זה הקובץ הפרטי. לשרת מגיע רק הקובץ שמסתיים ב-.pub.
- כדי שהשרת יאמת את הלקוח צריך להעתיק אליו את שני הקבצים. הפרטי לא יוצא מהלקוח לעולם. השרת מאמת חתימות בעזרת הציבורי בלבד.
- המפתח הציבורי הוא הסוד, ולכן לא מוסרים אותו לאף אחד. הפוך. הפרטי הוא הסוד, והציבורי נועד בדיוק לכך שיעתיקו אותו לשרתים.
- בזמן ההתחברות הלקוח שולח את המפתח הפרטי, והשרת משווה אותו לציבורי. הפרטי לא עובר ברשת. הלקוח שולח רק חתימה על האתגר, והשרת בודק אותה.
- בזוג המפתחות יש מפתח משותף שהוגדר מראש בשני הצדדים, ובו מוצפנת התעבורה. אין מפתח משותף מוכן מראש. מפתחות ההצפנה של החיבור מוסכמים בכל פעם מחדש בלחיצת היד, וזוג המפתחות משמש להזדהות.
- אפשר להתחבר בלי סיסמה בעזרת רשומה ב-known_hosts, או בעזרת PermitRootLogin yes. known_hosts מזהה את השרת, ו-PermitRootLogin רק קובע אם root רשאי להיכנס. הזדהות בלי סיסמה נעשית בזוג מפתחות.
- ssh-copy-id מעתיק לשרת את המפתח הפרטי, או רושם את הציבורי ב-known_hosts. הוא מעתיק רק את הציבורי, ורושם אותו ב-authorized_keys בשרת.
- Ed25519 משלם על המהירות במפתח ארוך יותר ובאבטחה נמוכה מ-RSA-4096. המפתח שלו קצר יותר, החתימה מהירה יותר, והאבטחה מאותו סדר גודל.
בדקו את עצמכם
יעל יצרה זוג מפתחות ורוצה להיכנס לשרת בלי סיסמה. איזה מהקבצים היא מתקינה בשרת, ולתוך איזה קובץ שם?
את הקובץ עם הסיומת .pub, כלומר הציבורי. הוא נכנס כשורה ב-authorized_keys שבתיקייה ~/.ssh של החשבון שלה בשרת.
תוקף פרץ לשרת וקרא את כל הקבצים בו. למה אין בידו סיסמה או מפתח שיאפשרו לו להתחבר בשם המשתמשים?
בשרת שמורים רק מפתחות ציבוריים, ואין סיסמה קבועה שהשרת קיבל. המפתח הפרטי לא הגיע לשרת אף פעם, כי הלקוח רק חותם על אתגרים.
בחיבור הראשון לשרת חדש, איזה צד שומר את המפתח של הצד השני, ובאיזה קובץ?
הלקוח שומר את מפתח המארח של השרת ב-known_hosts. השרת לא שומר את המפתח של הלקוח מעצמו, אלא רק אם הותקן ב-authorized_keys.
SSH: דגלים בשורת הפקודה והעברת קבצים
הדגלים של ssh שכדאי להכיר
לפקודה ssh יש עשרות אפשרויות. אלה שחוזרים עליהם שוב ושוב, כולל כמה זוגות שנראים כמעט זהים:
| דגל | מה הוא עושה |
|---|---|
-p 2222 | מתחבר לפורט אחר בשרת במקום ברירת המחדל 22. p קטנה. |
-C | מפעיל דחיסה (Compression) של התעבורה, שיכולה לעזור בקו איטי. C גדולה. |
-c | בוחר את אלגוריתם ההצפנה (cipher). c קטנה, ואין לו קשר לדחיסה. |
-f | אחרי שההזדהות מסתיימת, מעביר את תהליך ssh לרקע ומשחרר את הטרמינל. |
-N | לא מריץ שום פקודה בצד המרוחק. שימושי כשכל מטרת החיבור היא מנהרה, ואינו מעביר לרקע בעצמו. |
-T | לא מקצה טרמינל (pseudo-terminal) בצד המרוחק. |
-q | מצב שקט (Quiet) שמשתיק הודעות אזהרה. |
-L, -R, -D | העברת פורטים (Port Forwarding): מקומית, הפוכה ודינמית. |
-X, -Y | X11 Forwarding, כש-Y נותן לתוכנה המרוחקת אמון רחב יותר. |
-A | Agent Forwarding. |
-J | מתחבר דרך שרת ביניים (Jump Host). |
שלושה זוגות שבהם הכי קל להתבלבל:
-C(דחיסה) מול-c(בחירת cipher).-pקטנה בפקודהsshמול-Pגדולה בפקודותscpו-sftp, ובשני המקרים מדובר בפורט.-f(רקע) מול-N(בלי פקודה מרוחקת). כל אחד לבד לא מספיק למנהרה שקטה, ולכן משלבים אותם:-fN.
אפשר לבדוק איך ssh הבין את הדגלים בלי להתחבר לשום מקום: הדגל -G מדפיס את ההגדרות שהיו בתוקף לחיבור ויוצא. כאן רואים ש-C הגדולה הדליקה דחיסה ו-c הקטנה רק קבעה cipher:
ssh -G -p 2222 -C rina@build01 | grep -E "^(user|hostname|port|compression) "
ssh -G -c aes256-ctr rina@build01 | grep -E "^(ciphers|compression) "user rina
hostname build01
port 2222
compression yes
compression no
ciphers aes256-ctrושתי שורות כפי שהן נראות בשימוש אמיתי: התחברות לשרת שמאזין בפורט לא רגיל, ומנהרה שנשארת ברקע בלי פקודה מרוחקת:
ssh -p 2222 rina@build01
ssh -fN -L 5433:db-internal:5432 rina@bastionבפלט של -G שלמעלה כדאי לשים לב גם למה שלא זז. -p שינה רק את שורת port, ולכן החיבור נשאר חיבור SSH מוצפן מן המניין, לא Telnet ולא SFTP. -C שינה רק את שורת compression: SSH ממשיך לשבת על TCP ולא עובר ל-UDP, וגרסת הפרוטוקול לא קשורה לדחיסה בכלל.
SCP ו-SFTP: העתקה מול ניהול קבצים
SSH מגיע עם שני כלים נפוצים להעברת קבצים. שניהם עובדים בתוך חיבור SSH מוצפן, על אותו פורט 22, וההבדל ביניהם הוא במה שהם יודעים לעשות.
| נושא | SCP | SFTP |
|---|---|---|
| ייעוד | העתקה חד-פעמית של קבצים | ניהול קבצים בשרת מרוחק |
| מה אפשר לעשות | להעתיק, וזהו | לרשום תוכן תיקייה, לשנות שם, למחוק, לשנות הרשאות ולחדש העברה שנקטעה |
| הצפנה | מוצפן, כי הוא רץ בתוך SSH | מוצפן, כי הוא רץ בתוך SSH |
| פורט | 22, כמו SSH | 22, כמו SSH. אין קשר ל-FTP ולפורט 21 |
| כיוון | העלאה לשרת והורדה ממנו | העלאה לשרת והורדה ממנו |
| דגל הפורט | -P גדולה | -P גדולה |
# one-off copies with scp (upload, then download, to a server on port 2222)
scp -P 2222 invoices.zip mira@files.example.com:/srv/in/
scp -P 2222 mira@files.example.com:/srv/out/summary.xlsx .
# an interactive sftp session
sftp -P 2222 mira@files.example.com
sftp> ls /srv/out
sftp> rename draft.txt final.txt
sftp> rm old-backup.tar
sftp> put invoices.zip
sftp> get summary.xlsxלכן ההבדל בין הכלים אינו בהצפנה, לא בשרת שצריך ולא בפרוטוקול התעבורה. SFTP לא דורש שרת FTP נפרד: הוא רץ כתת-מערכת (subsystem) של שרת ה-SSH, בתוך אותו חיבור.
מה לא מתאים להעברה מאובטחת: FTP רגיל ו-HTTP רגיל לא מצפינים, ומי שמאזין רואה בהם את הקבצים ואת הסיסמה. גם חיבור Telnet לפורט 22 לא מעביר קבצים, כי Telnet לא מדבר את פרוטוקול SSH.
ssh-keygen, שכל תפקידו לייצר מפתחות, ו-cron, מתזמן המשימות של מערכת ההפעלה, שאינו חלק מ-SSH בכלל.תרחיש 10: קובץ אחד היום, ניהול תיקייה מחר
מירה צריכה להעלות היום קובץ חשבוניות לשרת, ובשבוע הבא גם לעבור על תיקייה, לשנות שם לקובץ טיוטה ולמחוק גיבוי ישן.
- להעלאה החד-פעמית של היום מספיק
scp. - לרשימת התיקייה, לשינוי השם ולמחיקה היא צריכה
sftp, כיscpיודע רק להעתיק.
בשני המקרים התעבורה מוצפנת, כי שני הכלים עובדים בתוך SSH.
טעויות נפוצות
- SFTP מצפין, ואילו SCP שולח את הקבצים בגלוי. שניהם רצים בתוך חיבור SSH ושניהם מוצפנים.
- SFTP עובד בפורט 21, כמו FTP. SFTP הוא חלק מ-SSH ועובד בפורט 22.
- SCP מעביר בשני הכיוונים, ו-SFTP יודע רק להעלות. שני הכלים מעלים לשרת ומורידים ממנו.
- כדי להשתמש ב-SFTP צריך להתקין בשרת גם שרת FTP. SFTP רץ כתת-מערכת של שרת ה-SSH, ואין צורך בשרת נוסף.
- ב-scp בוחרים פורט עם p קטנה, כמו ב-ssh. ב-scp וב-sftp הפורט הוא P גדולה. ב-ssh הוא p קטנה.
- -C בוחר את אלגוריתם ההצפנה. את ה-cipher בוחרים ב-c קטנה. C גדולה מדליקה דחיסה.
- -N שולח את ssh לרקע. לרקע שולח -f. הדגל -N רק מוותר על הרצת פקודה מרוחקת.
בדקו את עצמכם
שרת ה-SSH של המעבדה מאזין בפורט 2022. איך מתחברים אליו, ואיך מעתיקים אליו קובץ ב-scp?
ssh -p 2022 user@lab להתחברות, ו-scp -P 2022 file user@lab: להעתקה. ב-scp וב-sftp הדגל הוא P גדולה.
צריך לבדוק אילו קבצים יש בתיקייה בשרת ואז להעלות לשם קובץ. איזה כלי יעשה את שני הדברים?
SFTP. SCP רק מעתיק ואינו מציג רשימת קבצים.
SSH: מנהרות, העברת פורטים ושרתי ביניים
שלוש צורות של Port Forwarding
מנהרת SSH מובילה תעבורה של תוכנות אחרות דרך החיבור המוצפן שכבר פתוח. בעזרתה מצפינים שירות שאינו מצפין בעצמו, או מגיעים לשירות שאינו חשוף לכם ישירות.
יש שלוש צורות, וכדי להבדיל ביניהן שואלים שתי שאלות: באיזה מחשב נפתח הפורט שמאזין, ולאן מגיעה התעבורה שנכנסת אליו.
| דגל | שם | הפורט המאזין נפתח | התעבורה מגיעה אל |
|---|---|---|---|
-L | Local | במחשב שלכם (הלקוח) | יעד אחד קבוע, כפי שהשרת רואה אותו |
-R | Reverse | בשרת המרוחק | יעד אחד קבוע, כפי שהמחשב שלכם רואה אותו |
-D | Dynamic | במחשב שלכם | כל יעד שהתוכנה מבקשת, דרך פרוקסי SOCKS |
גם כאן -G מראה איך ssh פירש את הדגלים בלי להתחבר בפועל:
ssh -G -L 3000:wiki:80 -R 9090:localhost:5000 -D 1081 rina@gate | grep -E "^(localforward|remoteforward|dynamicforward) "dynamicforward 1081
localforward 3000 [wiki]:80
remoteforward 9090 [localhost]:5000ל--L ול--R יש פורט מאזין ויעד קבוע, ואילו ל--D יש רק פורט, בלי יעד.
Local Port Forwarding: ssh -L
ב--L אתם בוחרים פורט במחשב שלכם, ו-ssh מתחיל להאזין לו. כל חיבור שנכנס לפורט הזה עובר בתוך המנהרה אל שרת ה-SSH, ומשם ממשיך אל יעד שאתם קובעים מראש בצורה host:port.
# general form
ssh -L local_port:target_host:target_port user@ssh_server
# reach the build dashboard ci-board:8080 through the bastion, on local port 9000
ssh -L 9000:ci-board:8080 avi@bastion.example.comאחרי הפקודה, דפדפן במחשב של אבי שפונה ל-localhost:9000 מגיע בפועל ל-ci-board:8080. השם ci-board מתפרש בצד של bastion, ולכן הוא יכול להיות מכונה פנימית שהמחשב של אבי בכלל לא מסוגל לראות.
כך מגיעים למשאב פנימי ומוגן, למשל מסך הניהול של בסיס הנתונים, בלי לפתוח חורים בחומת האש ובלי לחשוף את השירות לאינטרנט.
-L אינו. הוא לא רשת פרטית וירטואלית (VPN) מלאה, כי עובר בו רק מה שנשלח לפורט שהוגדר. הוא לא ערוץ מיוחד ל-DNS, והוא לא חוסך הזדהות: בלי סיסמה או מפתח מול שרת ה-SSH אין מנהרה.אותו מנגנון מצפין שירות דואר ישן. בפקודה הבאה המילה localhost ביעד מתפרשת בצד של שרת הדואר, כלומר השרת עצמו:
ssh -L 2143:localhost:143 ella@mail.harbor.exampleבתוכנת הדואר מגדירים שרת IMAP בכתובת localhost ובפורט 2143. התעבורה נכנסת למנהרה ויוצאת ממנה אל פורט 143 בשרת הדואר, ובדרך היא מוצפנת.
תרחיש 11: לוח הבנייה הפנימי מהבית
לוח הבנייה ci-board של החברה זמין רק מתוך הרשת הפנימית. מהאינטרנט פתוח רק שרת SSH אחד בשם bastion, ומ-bastion אפשר להגיע ל-ci-board.
- אבי מריץ בבית
ssh -L 9000:ci-board:8080 avi@bastion.example.comומזדהה. - במחשב הביתי שלו נפתח פורט 9000 שמאזין.
- בדפדפן הוא פותח את
http://localhost:9000. - הבקשה נכנסת למנהרה, מגיעה ל-bastion, ומשם יוצאת אל ci-board:8080.
-R היה פותח את הפורט ב-bastion ולא בבית, -D היה מקים פרוקסי בלי יעד קבוע, ו--p משנה רק את פורט היעד של חיבור ה-SSH עצמו.
Reverse Port Forwarding: ssh -R
-R הוא תמונת הראי של -L. הפורט המאזין נפתח בשרת המרוחק, וכל חיבור שמגיע אליו חוזר דרך המנהרה אל יעד שהמחשב שלכם רואה.
# a web app runs on this laptop at port 5000; open port 7000 on the relay
ssh -R 7000:localhost:5000 tal@relay.exampleמכאן, כל חיבור אל localhost:7000 בתוך relay.example מגיע לפורט 5000 במחשב של טל. כאן localhost ביעד מתפרש בצד של טל, כי היעד של -R נקבע לפי מה שהמחשב המקומי רואה.
השיטה עובדת גם כשהמחשב של טל מסתתר מאחורי NAT, כי את חיבור ה-SSH הוא עצמו פתח כלפי חוץ. החיבורים הנכנסים מגיעים אליו בתוך החיבור שכבר קיים.
כדי לזכור: L מאזין במחשב שלכם, R מאזין בצד של השרת. ודגלים אחרים לא עושים את זה: -N רק מוותר על פקודה מרוחקת, -C דוחס ו--J מתחבר דרך שרת ביניים.
תרחיש 12: להראות לעמית אפליקציה שרצה על הלפטופ
טל מפתחת אפליקציה שרצה על הלפטופ שלה בפורט 5000, מאחורי NAT ביתי. עמית שעובד על relay.example רוצה לנסות אותה.
- טל מריצה
ssh -R 7000:localhost:5000 tal@relay.example. - ב-relay.example נפתח פורט 7000 שמאזין.
- העמית, שמחובר ל-relay.example, פונה ל-localhost:7000, והחיבור יורד במנהרה אל פורט 5000 בלפטופ של טל.
הפורט זמין רק מתוך relay.example עצמו, כי הוא קשור ל-loopback. אם רוצים לחשוף אותו מעבר לכך, צריך GatewayPorts.
פרוקסי דינמי: ssh -D
-D מקבל רק מספר פורט מקומי, בלי יעד, והופך אותו לפרוקסי SOCKS דינמי. כל תוכנה שתגדירו להשתמש בפרוקסי הזה, למשל דפדפן, תוכל לבקש דרכו כל יעד שהיא רוצה, והחיבור ייצא לעולם מהשרת.
# local SOCKS proxy on port 1081, no remote command
ssh -D 1081 -N ori@exit.exampleב--L כל פורט מקומי מוביל ליעד אחד שנקבע מראש. ב--D היעד נבחר מחדש בכל בקשה, ולכן אחד יכול לשרת את כל האתרים שהדפדפן פותח.
SSH Agent Forwarding
המצב: אתם מתחברים מהלפטופ לשרת א', ומשם צריכים להמשיך לשרת ב' עם אותו מפתח. הפתרון הנאיבי הוא להעתיק את המפתח הפרטי לשרת א', וזה מסוכן, כי עכשיו הסוד שלכם יושב על מכונה נוספת.
ב-Agent Forwarding המפתח הפרטי לא זז מהלפטופ, שם מחזיקה אותו התוכנה ssh-agent. כששרת ב' דורש חתימה, הבקשה חוזרת דרך socket שמועבר בתוך חיבור ה-SSH אל ה-agent המקומי, וה-agent חותם בשמכם.
ssh -A dana@jump-a
# now on jump-a: the signature request goes back to the agent on the laptop
ssh dana@db-bבסביבה עם הרבה שרתים זה היתרון: עוברים משרת לשרת בצורה שקופה ומאובטחת, בלי לפזר עותקים של המפתח הפרטי, והמפתח לא נחשף בשרתים שבדרך.
-A רק מול שרתים שסומכים עליהם.שני מנגנונים עם שם דומה עושים דברים אחרים לגמרי:
- Port Forwarding מעביר דרך חיבור ה-SSH תעבורת רשת של תוכנות אחרות.
- ControlMaster פותח חיבור ראשי אחד, וכל פקודת
sshנוספת לאותו שרת רוכבת עליו במקום להתחבר מחדש, ולכן היא עולה כמעט מיד.
בכל התהליך עוברות ברשת רק בקשות חתימה והחתימות עצמן, ולכן שום עותק של המפתח לא נוחת בשרת א'. זה מנגנון הזדהות ולא ניתוב: הוא לא פותח מעבר דרך חסימות רשת, וגם לא מאחד חיבורים, שזו העבודה של ControlMaster. ומעבר לחתימות הוא לא נוגע בשרת: sudo נשאר כמו שהיה, RSA לא כבה, וקבצי authorized_keys לא משתנים.
X11 Forwarding
בלינוקס, את החלונות הגרפיים מצייר X11. העברת X11 (X11 Forwarding) מאפשרת להפעיל תוכנה עם ממשק גרפי על מכונה מרוחקת ולראות את החלון שלה על המסך שמולכם.
ssh -X gil@render-node
# on render-node: the window opens on the local screen
xeyesמפעילים את זה ב--X, או ב--Y שסומך על התוכנה המרוחקת במידה רבה יותר. ציורי החלון והקלט שלכם נוסעים בתוך חיבור ה-SSH, ולכן גם הם מוצפנים.
אפשר גם לחבר תוכנה ישירות לפורט 6000, שבו מאזין שרת X כרגיל, וגם כך יוצג חלון מרחוק. אבל חיבור כזה לא עובר דרך SSH, ולכן שום דבר בו לא מוצפן.
known_hosts לא קשור לתצוגה גרפית, ו-scp מעתיק קבצים ולא מציג חלונות. -G מאשר שהדגלים -A ו--X מדליקים בדיוק את שתי ההעברות האלה, שכבויות כברירת מחדל:
ssh -G -A -X rina@gate | grep -E "^(forwardagent|forwardx11) "
ssh -G rina@gate | grep -E "^(forwardagent|forwardx11) "forwardx11 yes
forwardagent yes
forwardx11 no
forwardagent noשרת ביניים: ProxyJump ו-ProxyCommand
לפעמים שרת היעד לא נגיש ישירות, וצריך לעבור דרך שרת ביניים (Jump Host). בקובץ ~/.ssh/config יש לכך שני מנגנונים:
- ProxyJump (בשורת הפקודה:
-J) הוא הדרך המובנית. כותבים בהגדרה את שרת הביניים, או שרשרת של כמה שרתים מופרדים בפסיק. - ProxyCommand נותן לכם לכתוב בעצמכם את הפקודה שתפתח את הקשר אל היעד, למשל
nc -w 10 %h %p, ו-ssh ידבר דרכה. החופש הזה גמיש יותר, ובתמורה דורש הגדרה ידנית מפורטת.
# command line, through two jump hosts in a row
ssh -J rina@edge1,rina@edge2 rina@vault
# the same in ~/.ssh/config
Host vault
ProxyJump rina@edge1,rina@edge2
# the older, manual way
Host vault-old
HostName vault
ProxyCommand ssh -W %h:%p rina@edge1ProxyJump שקול ל-ProxyCommand שמריץ ssh -W, רק בתחביר קצר שמכסה את המקרים הנפוצים. כך ssh קורא את השרשרת:
ssh -G -J rina@edge1,rina@edge2 rina@vault | grep ^proxyjumpproxyjump rina@edge1,rina@edge2בשני המנגנונים החיבור עובר בערוץ SSH מוצפן, ואף אחד מהם לא מעתיק מפתחות לשרתים. ו-ProxyJump לא מוגבל לשרת ביניים אחד: השרשרת למעלה עוברת דרך שניים.
חזרה לתוכן הענייניםמנהרה ברקע, טעויות ובדיקה
תרחיש 13: מנהרה שעובדת כל היום ברקע
אלה רוצה שמנהרת הדואר שלה תישאר פתוחה כל יום העבודה, בלי חלון טרמינל תפוס ובלי מעטפת מרוחקת פתוחה.
היא מריצה ssh -fN -L 2143:localhost:143 ella@mail.harbor.example. בזכות -N לא רצה שום פקודה בשרת, ובזכות -f התהליך עובר לרקע ברגע שההזדהות הסתיימה.
כל דגל לבד לא מספיק: בלי -f הטרמינל נשאר תפוס, ובלי -N נפתחת מעטפת מרוחקת שאיש לא משתמש בה.
טעויות נפוצות
- -R פותח פורט במחשב המקומי. -R פותח את הפורט בשרת המרוחק. במחשב שלכם הפורט נפתח עם
-L. - לדגל -D צריך לציין יעד קבוע. -D מקבל פורט מקומי בלבד, והיעד נבחר בכל בקשה דרך פרוקסי SOCKS.
- -p 8080 מעביר את פורט 8080 דרך המנהרה. -p בוחר את הפורט שבו שרת ה-SSH מאזין, ולא מעביר שום תעבורה. העברת פורטים נעשית ב--L, -R או -D.
- Local Forwarding הוא VPN מלא, ואפשר להיכנס בו בלי סיסמה או מפתח. הוא מעביר רק את הפורט שהוגדר, וההזדהות מול שרת ה-SSH נדרשת כרגיל.
- Agent Forwarding שולח לשרת המרוחק עותק של המפתח הפרטי. המפתח נשאר במחשב המקומי. רק בקשות החתימה עוברות אל ה-agent.
- Agent Forwarding מריץ כמה חיבורים על ערוץ TCP אחד. זה תפקידו של ControlMaster.
- X11 Forwarding מפעילים ברשומה בשם X11 ב-known_hosts, או ב-scp עם המשתנה DISPLAY. מפעילים אותו בהתחברות עם ssh -X או ssh -Y.
- כשהתוכנה מתחברת ישירות לפורט 6000, התעבורה מוצפנת בדיוק כמו ב-X11 Forwarding. רק תעבורה שעוברת בתוך SSH מוצפנת. החיבור הישיר גלוי.
- ProxyJump מתאים רק לשרת ביניים אחד, ו-ProxyCommand נועד לחיבור ישיר בלי ביניים. ProxyJump מקבל גם שרשרת, ו-ProxyCommand מריץ פקודה שמקימה את החיבור, בדרך כלל דרך שרת ביניים.
בדקו את עצמכם
מהלפטופ רוצים לפתוח בדפדפן את המערכת הפנימית hr-portal בפורט 443, דרך שרת ה-SSH gw, כשהדפדפן פונה לפורט מקומי 8443. מה הפקודה?
ssh -L 8443:hr-portal:443 user@gw, ואז פונים בדפדפן ל-localhost:8443.
באיזה מחשב נפתח הפורט המאזין עם -L, ובאיזה עם -R?
עם -L הוא נפתח במחשב שלכם, והתעבורה יוצאת מהשרת אל היעד. עם -R הוא נפתח בשרת המרוחק, והתעבורה חוזרת אל יעד שהמחשב שלכם רואה.
למה עדיף -A על העתקת המפתח הפרטי לשרת הביניים?
כי המפתח הפרטי נשאר רק במחשב המקומי ולא נחשף בשרתים שבדרך. השרת המרוחק רק מבקש חתימות מה-agent.
SSH: קבצי הגדרות בלקוח ובשרת
~/.ssh/config בלקוח ובדיקות keep-alive
ל-SSH יש שני קבצי הגדרות נפרדים: ~/.ssh/config שקובע איך הלקוח מתחבר, ו-sshd_config שקובע איך השרת מתנהג. חלק גדול מהשאלות בנושא בודקות דבר אחד: לאיזה מהשניים שייכת הגדרה מסוימת.
בקובץ של הלקוח שומרים פרטים לכל שרת, ומאותו רגע מספיק להקליד את הכינוי. בניסוי שמרנו את הקובץ בתיקיית הניסוי, הפנינו אליו את ssh בעזרת -F, ובדקנו ב--G מה נכנס לתוקף:
cat > lab/config <<'EOF'
Host lab
HostName lab.example.net
User yoav
Port 2200
ServerAliveInterval 45
ServerAliveCountMax 4
ProxyJump yoav@gate.example.net
EOF
ssh -G -F lab/config lab | grep -E "^(hostname|user|port|serveraliveinterval|serveralivecountmax|proxyjump) "user yoav
hostname lab.example.net
port 2200
serveralivecountmax 4
serveraliveinterval 45
proxyjump yoav@gate.example.netעכשיו לבעיה שההגדרות האלה פותרות. רכיבי ביניים כמו NAT וחומות אש זוכרים כל חיבור בטבלה, וחיבור שלא עברה בו תעבורה זמן רב נראה להם נטוש. הם מוחקים אותו מהטבלה, והסשן מת בלי הודעה.
התרופה היא keep-alive: הודעות בדיקה קטנות שיוצאות במרווחים קבועים. כך תמיד יש תעבורה והחיבור נשאר בטבלה, ואם הרשת באמת נפלה, הלקוח מגלה את זה מהר במקום לחכות.
ServerAliveInterval היא הגדרה של הלקוח. היא קובעת אחרי כמה שניות בלי תעבורה הלקוח שולח לשרת הודעת בדיקה, בתוך חיבור ה-SSH המוצפן.
ServerAliveCountMax קובעת כמה הודעות כאלה ברצף יכולות להישאר בלי תשובה. כשהמכסה נגמרת, הלקוח מנתק בעצמו, וכך לא נשארים חיבורים מתים ברשת Wi-Fi או סלולרית שאינה יציבה.
בלי הגדרה בכלל, הבדיקות האלה כבויות: הערך 0 פירושו שלא נשלחת אף הודעה. הקובץ /dev/null משמש כאן כקובץ הגדרות ריק:
ssh -G -F /dev/null lab | grep -E "^(serveraliveinterval|serveralivecountmax|tcpkeepalive) "tcpkeepalive yes
serveralivecountmax 3
serveraliveinterval 0ארבע הגדרות עם שמות קרובים, ומה מבדיל ביניהן:
| הגדרה | של מי | מה היא עושה |
|---|---|---|
ServerAliveInterval | הלקוח | הלקוח בודק שהשרת עדיין שם, בהודעה בתוך SSH |
ClientAliveInterval | השרת (sshd_config) | השרת בודק שהלקוח עדיין שם, כלומר אותו רעיון בכיוון ההפוך |
TCPKeepAlive | מערכת ההפעלה, ברמת TCP | בדיקות של TCP עצמו, מחוץ לפרוטוקול SSH |
RekeyLimit | לקוח ושרת | מתי מחליפים את מפתחות ההצפנה של החיבור. אין לה קשר לבדיקות נוכחות |
ServerAliveInterval עוסקת בבדיקת נוכחות ותו לא. החלפת מפתחות שייכת ל-RekeyLimit, הגבלת ניסיונות סיסמה ל-MaxAuthTries בשרת, ודחיסה לדגל -C.
sshd_config: הגדרות השרת והקשחתו
sshd הוא תהליך השרת של SSH, והקובץ sshd_config קובע את ההתנהגות שלו. אלה ההגדרות שכדאי להכיר:
| הגדרה | על מה היא שולטת |
|---|---|
Port, ListenAddress | איפה השרת מאזין: באיזה פורט ועל איזו כתובת |
MaxAuthTries | התקרה של טעויות כניסה בתוך חיבור יחיד. מי שחוצה אותה נזרק החוצה |
LoginGraceTime | כמה זמן השרת מחכה שההזדהות תושלם לפני שהוא מנתק |
AllowUsers, DenyUsers | סינון לפי שם משתמש: מי רשאי להיכנס ומי חסום |
ClientAliveInterval, ClientAliveCountMax | בדיקות נוכחות מצד השרת לחיבורים שכבר עברו הזדהות |
PermitRootLogin | האם מותר להתחבר ישירות כ-root (הטבלה הבאה) |
ההגדרה MaxAuthTries עובדת יחד עם LoginGraceTime נגד ניחוש סיסמאות בכוח (Brute-Force). הראשונה מגבילה את מספר הניסיונות בכל חיבור, והשנייה מקצרת את החלון שבו אפשר לנסות.
| ערך של PermitRootLogin | מה הוא מתיר |
|---|---|
yes | כניסה ישירה כ-root, גם בסיסמה וגם במפתח |
prohibit-password | root נכנס במפתח בלבד. בסיסמה הוא נחסם |
forced-commands-only | root נכנס במפתח, ורק כדי להריץ פקודה אחת שהוגדרה מראש |
no | אף כניסה ישירה כ-root, בשום שיטת הזדהות |
בהקשחה בוחרים בדרך כלל no. אחריו אין מבחוץ חשבון root שאפשר לנחש לו סיסמה, ומי שצריך הרשאות מנהל נכנס בשם המשתמש שלו ועובר ל-root עם sudo.
שאר הערכים בטבלה משאירים ל-root דרך להיכנס ישירות. prohibit-password ו-forced-commands-only מצמצמים אותה לכניסה עם מפתח, ו-yes לא מצמצם דבר ומשאיר את כל הדלתות פתוחות.
# /etc/ssh/sshd_config (excerpt of a hardened server)
Port 4422
PermitRootLogin no
MaxAuthTries 3
LoginGraceTime 30
PasswordAuthentication no
AllowUsers yoav mira
ClientAliveInterval 120
ClientAliveCountMax 2השורה Port 4422 מעבירה את השרת מפורט ברירת המחדל 22 לפורט אחר. סורקים אוטומטיים באינטרנט מנסים קודם כול את הפורט המוכר, ולכן במקום אחר מגיעים הרבה פחות ניסיונות התקפה אוטומטיים.
תרחיש 14: החיבור נופל בכל הפסקת קפה
יואב עובד מנקודה חמה של הטלפון. אחרי כמה דקות שבהן הוא לא מקליד כלום, הסשן מול השרת מת.
- בזמן ההפסקה לא עוברת תעבורה, ורכיב ה-NAT של הספק מסיק שהחיבור נטוש ומוחק אותו מהטבלה.
- יואב מוסיף ל-
~/.ssh/configאת השורהServerAliveInterval 45. - מעכשיו, אחרי 45 שניות של שקט, הלקוח שולח הודעה קטנה בתוך החיבור. ה-NAT רואה תעבורה, והחיבור שורד.
ההגדרה הזו שייכת ללקוח. ב-sshd_config ההגדרה המקבילה, שבה השרת הוא ששולח, היא ClientAliveInterval.
תרחיש 15: הקשחה של שרת שחוטף ניסיונות ניחוש
ביומן של שרת ה-SSH יש אלפי ניסיונות כניסה כושלים ביום, ומירה רוצה לצמצם את הסיכון.
- ב-
sshd_configהיא קובעתPermitRootLogin no, ו-root כבר לא יכול להתחבר ישירות. - היא מקטינה את
MaxAuthTriesומקצרת אתLoginGraceTime, וכך כל חיבור מקבל מעט ניסיונות וזמן קצר. - היא עוברת להזדהות במפתחות ומשאירה ב-
AllowUsersרק את המשתמשים שצריכים גישה. - בנוסף היא מעבירה את השרת לפורט אחר. זה מוריד את הרעש של סורקים אוטומטיים, אבל אינו הגנה של ממש.
טעויות נפוצות
- ServerAliveInterval מוגדרת בשרת. זו הגדרה של הלקוח. המקבילה בשרת היא ClientAliveInterval.
- ServerAliveInterval קובעת כל כמה זמן מחליפים מפתחות הצפנה, או כמה פעמים מותר לטעות בסיסמה. היא קובעת רק מתי הלקוח שולח הודעת בדיקה. החלפת מפתחות היא RekeyLimit, והגבלת ניסיונות היא MaxAuthTries.
- TCPKeepAlive היא חלק מפרוטוקול SSH. זה מנגנון של TCP שמערכת ההפעלה מפעילה, מחוץ ל-SSH.
- prohibit-password חוסם כל כניסה ישירה של root. הוא חוסם רק כניסה בסיסמה, ומפתח עדיין עובד. רק no חוסם הכול.
- MaxAuthTries, יחד עם LoginGraceTime, קובעת על איזה פורט השרת מאזין. הפורט נקבע בהגדרה Port, והכתובת בהגדרה ListenAddress. MaxAuthTries מגבילה את מספר הניסיונות, ו-LoginGraceTime את הזמן להזדהות.
- שינוי הפורט של SSH מצפין את התעבורה, או מאפשר לוותר על הזדהות. הוא רק מקטין את מספר הסריקות האוטומטיות. ההצפנה וההזדהות לא תלויות בו.
- כשמפתח המארח של השרת משתנה, סיסמת המשתמש פגה. אלה שני עניינים נפרדים. מפתח המארח מזהה את השרת, והסיסמה שייכת לחשבון.
בדקו את עצמכם
מנהלת רוצה שאיש לא יתחבר כ-root ישירות, אפילו לא בעזרת מפתח. איזה ערך היא נותנת ל-PermitRootLogin?
no. הערך prohibit-password חוסם רק סיסמה ומשאיר את המפתח פתוח.
אילו שתי הגדרות ב-sshd_config מגבילות כמה פעמים אפשר לנסות להזדהות בחיבור אחד וכמה זמן יש לכך?
MaxAuthTries למספר הניסיונות, ו-LoginGraceTime לזמן.
בהגדרה ServerAliveInterval 45, מי שולח את הודעת הבדיקה ולאן?
הלקוח שולח אותה לשרת, בתוך חיבור ה-SSH, אחרי 45 שניות בלי תעבורה.
סיכום
- HTTP: ב-GET הפרמטרים נכנסים לכתובת אחרי ה-?, ולכן הם נשמרים בהיסטוריה, בסימניות וביומני השרת. הבקשה בטוחה, אידמפוטנטית ומתאימה לשליפה, לשיתוף קישור ולמטמון.
- ב-POST הנתונים בגוף הבקשה. היא מתאימה לטפסים, לשינוי נתונים ולכמויות גדולות, ושליחה חוזרת שלה עלולה לבצע פעולה פעמיים. אף אחת מהשיטות לא מצפינה: את זה עושה HTTPS, וקידוד כמו urlencoded או Base64 אינו הצפנה.
- דואר: SMTP שולח, IMAP ו-POP3 קוראים. ב-IMAP ההודעות, התיקיות ומצב הקריאה נשארים בשרת ומסונכרנים בין כל המכשירים, ואילו POP3 בדרך כלל מוריד את ההודעות למכשיר.
- IMAP רגיל עובד בפורט 143 בגלוי. STARTTLS משדרג את אותו חיבור להצפנה אחרי ש-CAPABILITY הראתה שהוא מוצע, ו-IMAPS מוצפן מההתחלה בפורט 993. אימות PLAIN הוא רק Base64, ו-IDLE מחליפה polling בהתראות מהשרת.
- Telnet: גישה לטרמינל מרוחק בפורט 23 מעל TCP, בלי שום הצפנה. היום משתמשים בו לבדוק אם פורט TCP פתוח (telnet host port) ולדבר ביד עם פרוטוקול טקסטואלי.
- SSH: פורט 22 מעל TCP. לחיצת היד מסכימה על אלגוריתמים ומקימה ערוץ מוצפן עוד לפני ההזדהות, ומפתח המארח, שנשמר ב-known_hosts, מוכיח ללקוח שהשרת הוא השרת הנכון.
- זוג מפתחות: הפרטי נשאר בלקוח, הציבורי נכנס ל-authorized_keys בשרת (ssh-copy-id עושה את זה), והלקוח רק חותם על אתגר. Ed25519 קצר ומהיר מ-RSA-4096 באבטחה דומה.
- דגלים:
-pהוא הפורט ב-ssh ו--Pב-scp וב-sftp,-Cדוחס ו--cבוחר cipher, והצירוף-fNמשאיר מנהרה ברקע. SCP רק מעתיק, SFTP גם מנהל קבצים, ושניהם מוצפנים בפורט 22. - מנהרות:
-Lפותח פורט אצלכם,-Rפותח פורט בשרת המרוחק, ו--Dמקים פרוקסי SOCKS.-Aמשאיר את המפתח הפרטי במחשב המקומי,-Xמציג חלון גרפי מרוחק בתוך SSH, ו--Jעובר דרך שרת ביניים אחד או שרשרת. - הגדרות: ServerAliveInterval היא של הלקוח, ו-ClientAliveInterval המקבילה שלה בשרת. בשרת MaxAuthTries מגבילה ניסיונות ו-LoginGraceTime מגבילה זמן, וכך נבלם ניחוש סיסמאות, רק PermitRootLogin no חוסם את root לגמרי, ושינוי פורט רק מוריד רעש של סורקים.
השוואה אחרונה בין שני הכלים לגישה מרחוק:
| נושא | Telnet | SSH |
|---|---|---|
| פורט | 23, מעל TCP | 22, מעל TCP |
| הצפנה | אין. הכול עובר כטקסט קריא | כל התעבורה מוצפנת, גם הסיסמה |
| זיהוי השרת | אין | מפתח מארח שנשמר ב-known_hosts |
| הזדהות המשתמש | שם וסיסמה שעוברים בגלוי | סיסמה בתוך הערוץ המוצפן, או זוג מפתחות |
| העברת קבצים | אין | SCP ו-SFTP |
| מנהרות והעברת פורטים | אין | יש |
| השימוש היום | בדיקה אם פורט TCP פתוח ושיחה ידנית עם פרוטוקול טקסטואלי | ניהול מרחוק מאובטח |
היתרון של SSH הוא אבטחה, בזכות ההצפנה. הוא לא מהיר יותר מ-Telnet ולא מתיר יותר חיבורים במקביל. ל-Telnet אין הזדהות במפתחות ואין שום דרך לוודא שהשרת הוא מי שהוא טוען.
Wireshark לוכד חבילות, והפעולה Follow TCP Stream מרכיבה מהן מחדש את כל השיחה של חיבור אחד. פילטר תצוגה כמו tcp.port == 22, או 23 כשמחפשים Telnet, משאיר על המסך רק את החיבור הרצוי.
| מה נלכד | מה מראה Follow TCP Stream |
|---|---|
| Telnet בפורט 23 | שם המשתמש, הסיסמה, הפקודות והתשובות, הכול קריא |
| SSH בפורט 22 | נתונים מוצפנים שאי אפשר לקרוא, כולל הסיסמה. גלויים רק פרטים כמו שורת הגרסה (banner) בפתיחת השיחה |
| HTTP רגיל | כל הבקשה בטקסט קריא: הכתובת, פרמטרי ה-GET וגוף ה-POST |
| IMAP בפורט 143 בלי STARTTLS | הפקודות ותוכן ההודעות. הסיסמה קריאה ב-LOGIN, ובקידוד Base64 ב-AUTHENTICATE PLAIN |
| פורט | שירות |
|---|---|
| 22 | SSH, וגם SCP ו-SFTP |
| 23 | Telnet |
| 25 | SMTP, שליחת דואר |
| 80 | HTTP |
| 110 | POP3 |
| 143 | IMAP, בגלוי או עם STARTTLS |
| 443 | HTTPS |
| 993 | IMAPS, כלומר IMAP מעל TLS |
| 995 | POP3 מעל TLS |
תרחיש 16: שתי התחברויות לאותו מתג, שתי תמונות שונות
מנהלת הרשת פותחת ב-Wireshark הקלטה שיש בה שתי התחברויות למתג אחד: אחת ב-Telnet לפורט 23, ואחת ב-SSH לפורט 22. על כל אחת היא מריצה Follow TCP Stream.
- בהתחברות ה-Telnet שום דבר לא מוצפן, ולכן שם המשתמש והסיסמה מופיעים כטקסט רגיל.
- בהתחברות ה-SSH הערוץ הוצפן עוד לפני שלב ההזדהות, ולכן הסיסמה לא קריאה.
- בשיחת ה-SSH הדבר היחיד שאפשר לקרוא הוא שורת הגרסה שבפתיחה.
המסקנה: Telnet חושף את פרטי ההתחברות לכל מי שמאזין, ו-SSH לא. זו סיבה מספיקה לוותר על Telnet ולעבור ל-SSH בשרתי ייצור.
בדקו את עצמכם
באילו פורטים עובדים כברירת מחדל SSH, Telnet ו-IMAP מוצפן?
SSH ב-22, Telnet ב-23, ו-IMAPS ב-993.
במה שונה Follow TCP Stream על בקשה ב-HTTP רגיל מאותה פעולה על חיבור SSH?
ב-HTTP רגיל כל הבקשה קריאה. ב-SSH התוכן מוצפן, ורק שורת הגרסה בתחילת השיחה גלויה.