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

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פרוטוקול תעבורה אמין, שמקים חיבור לפני שהוא מעביר נתונים.
לחיצת היד המשולשת של TCPSYN מהלקוח, SYN-ACK מהשרת, ACK מהלקוח. רק אחריה החיבור פתוח.

HTTP: השיטות GET ו-POST

בקשה, תשובה, וממה בנויה בקשה

HTTP היא שיחה של בקשה ותשובה בין דפדפן לשרת אינטרנט, מעל TCP: בדרך כלל בפורט 80, ובפורט 443 כשמדובר בגרסה המוצפנת, HTTPS. הדרך הקצרה ביותר להבין אותה היא להסתכל על בקשות אמיתיות.

כדי לראות מה באמת יוצא מהמחשב, הפעלנו את nc כמאזין שרק מדפיס כל בית שמגיע אליו, חיכינו שנייה שיתחיל להאזין, ושלחנו אליו בקשת GET בעזרת curl:

Bash
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:

Bash
nc -l 127.0.0.1 8101 & sleep 1
curl -s -m 1 -d 'user=noa&pin=4821' http://127.0.0.1:8101/signin
פלט
POST /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, ובעברית מחרוזת שאילתה.

Text
/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 תווים:

Bash
essay=$(python3 -c "print('a' * 70000)")
curl -s -i "http://127.0.0.1:8088/feedback?text=$essay" | head -1
פלט
HTTP/1.0 414 Request-URI Too Long

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

התיקון הוא להעביר את הטופס ל-POST, שם הטקסט נוסע בגוף, ולגוף אין תקרה כזו.

תרחיש 3: החנות שהתרוקנה בלילה

בבוקר גילו בחנות מקוונת שכל המוצרים בקטגוריה אחת נמחקו. ביומן השרת מופיעה שורה אחרי שורה כמו GET /products/remove?id=88, וכולן הגיעו מסורק של מנוע חיפוש.

ההסבר: בממשק הניהול, ליד כל מוצר, היה קישור רגיל למחיקה, ולחיצה על קישור היא GET. הסורק עבר על כל הקישורים בעמוד, כי GET אמורה להיות safe ולכן מותר לבקש אותה בלי לשאול. אותו דבר יכול לקרות בגלל טעינה מוקדמת (prefetch) של הדפדפן, ובנוסף תשובות GET עלולות להישמר במטמון ולהציג תמונה לא עדכנית.

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

היבטGETPOST
מיקום הנתוניםב-URL, אחרי ?בגוף הבקשה
ייעודשליפת מידעשליחת טופס, יצירה או עדכון של נתונים
שינוי בשרתלא אמורה לשנות (safe)בדרך כלל משנה
שליחה כפולהאותו מצב כמו שליחה אחת (idempotent)עלולה לבצע את הפעולה פעמיים
מועדפים ושיתוף קישוראפשרי, הפרמטרים חלק מהכתובתלא אפשרי, הכתובת לא נושאת אותם
היסטוריה ויומני שרתהפרמטרים נרשמים יחד עם הכתובתלא נרשמים כחלק מהכתובת
נפחמוגבל בפועל באורך ה-URLמתאים לנפח גדול
מטמון (cache)מתאימה לשמירהבדרך כלל לא נשמרת
הצפנהאיןאין. רק HTTPS מצפין, ושתי השיטות נהנות ממנו באותה מידה

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

  1. האם הבקשה משנה משהו בשרת? אם כן, POST (החנות שהתרוקנה).
  2. האם הנתונים עלולים להיות ארוכים? אם כן, POST (השרת שהחזיר 414).
  3. האם יש בעיה שהנתונים יישארו בכתובת, בהיסטוריה וביומנים, למשל כי הם רגישים? אם כן, 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 נבחר באקראי בכל הרצה, ולכן אצלכם הוא יהיה אחר):

Bash
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/share
פלט
POST /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, 587465, או 587 עם STARTTLS
IMAPניגש לתיבה שנשארת בשרת143993
POP3מוריד את הדואר אל המכשיר110995

השם IMAP הוא קיצור של Internet Message Access Protocol, והמילה החשובה בו היא Access. התוכנה שלכם ניגשת לתיבה שבשרת ומציגה ממנה תיקיות והודעות, בלי לקחת אותן הביתה. שאלות רבות בודקות אם ברור לכם מה שייך לו ומה לא:

משימהמי עושה אותה
לקרוא את ההודעות שבתיבה בשרתIMAP (או POP3)
לשלוח הודעה ליעדSMTP, לא IMAP
לתרגם שם של שרת דואר לכתובת IPDNS, לא IMAP
להעביר קבצים בין מחשביםפרוטוקולים כמו SFTP, לא IMAP
חזרה לתוכן העניינים

המודל של IMAP: השרת הוא מקור האמת

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

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

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

  • IMAP רץ מעל TCP.
  • הוא מנהל תיקיות רבות בצד השרת.
  • כמה תוכנות יכולות לפתוח את אותה תיבה באותו זמן.
  • ברשימת הודעות ארוכה מספיקים לו בהתחלה השולח והנושא של כל הודעה. את התוכן המלא הוא מושך רק כשלוחצים על הודעה.
IMAPPOP3 (במצב הרגיל)
היכן ההודעותנשארות בשרתיורדות למכשיר ונמחקות מהשרת
כמה מכשיריםכולם רואים את אותה תיבהלכל מכשיר עותק נפרד
תיקיות וסימוני קריאהמסונכרניםלא מסונכרנים
היתרון העיקריסנכרון מלא בין המכשיריםפשטות, והדואר שמור אצלכם
תרחיש 5: למה המחשב לא יודע מה עשיתי בטלפון?

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

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

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

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

IMAP מוצפן: IMAPS בפורט 993 או STARTTLS בפורט 143

TLS היא שכבת הצפנה שנכנסת בין TCP לבין פרוטוקול האפליקציה. IMAP ממשיך לדבר באותן פקודות בדיוק, אבל כל בית שלו עובר מוצפן. בלי TLS, IMAP בפורט 143 גלוי לכל מי שמאזין לקו.

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

  • IMAPS: פורט נפרד, 993. החיבור מוצפן מהבית הראשון, עוד לפני ששורת הברכה של השרת מגיעה.
  • STARTTLS: מתחברים לפורט 143 הרגיל, ובשלב מסוים הלקוח שולח את הפקודה STARTTLS, ואותו חיבור עצמו משודרג להצפנה.

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

Text
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:9143IMAP רגיל, בתוך המחשב עצמואין מאזין, התעבורה לא יוצאת מהמחשב
מהמחשב אל legacy-mail.example, פורט 22חיבור SSH שעוטף את ה-IMAPרק תעבורת SSH מוצפנת
בתוך השרת, אל פורט 143 שלוIMAP רגיל שובשום דבר ברשת, זה קורה בתוך השרת
חזרה לתוכן העניינים

הזדהות ב-IMAP: למה PLAIN צריך TLS

הזדהות ב-IMAP היא שם משתמש וסיסמה. במנגנון PLAIN, שמופעל בפקודה AUTHENTICATE PLAIN, שני הפרטים יוצאים מקודדים ב-Base64.

נניח שהקלטתם חיבור IMAP גלוי ומצאתם בו את המחרוזת AG1heWEAVHVsaXAjNzc=. כמה עבודה נדרשת כדי לגלות את הסיסמה?

Python
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 recovers
פלט
AG1heWEAVHVsaXAjNzc=
b'\x00maya\x00Tulip#77'

שורה אחת. המשתמש maya והסיסמה Tulip#77 חוזרים בדיוק כפי שהוקלדו, והבתים \x00 הם רק המפרידים שהמנגנון שם ביניהם. אין שם מפתח RSA שצריך לשבור, וגם לא זיהוי לפי הכתובת שממנה הלקוח מתחבר: יש פענוח Base64, וזהו.

מכאן שבלי TLS הפרטים חשופים לגמרי, וההגנה היא להריץ את IMAP מעל TLS: STARTTLS בפורט 143 או IMAPS בפורט 993.

מנגנוןמה עובר בקומה מאזין מרוויח בלי TLS
PLAINשם המשתמש והסיסמה, מקודדים ב-Base64את הסיסמה עצמה
CRAM-MD5השרת שולח אתגר, ערך אקראי, והלקוח מחזיר גיבוב שחושב מהאתגר ומהסיסמהלא את הסיסמה, כי היא לא נשלחת בכלל
רוצים לראות את זה בעיניים? פתחו ב-Wireshark לכידה של IMAP בפורט 143 בלי STARTTLS ובחרו Follow TCP Stream. כל הפקודות ותוכן ההודעות יוצגו כטקסט רגיל.
חזרה לתוכן העניינים

פקודות IMAP, תגיות ו-IDLE

בשיחה שלמעלה כל שורה של הלקוח נפתחה במילה קצרה, t1, t2 וכן הלאה. זו התגית (tag): הלקוח בוחר אותה, והשרת חוזר עליה בשורה שמסיימת את הטיפול בפקודה, כך שגם כשהשרת שולח כמה שורות ביניים, ברור איזו פקודה הסתיימה. IMAP כולו בנוי כך, משורות טקסט של פקודה ותשובה.

אחרי ההזדהות, שיחה טיפוסית ממשיכה כך (S הוא השרת, C הוא הלקוח):

Text
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:

Bash
telnet 10.20.30.40

עם פורט, הלקוח פונה בדיוק אליו ולא חוזר ל-23:

Bash
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, אבל המשמעות זהה:

Bash
telnet 127.0.0.1 2525
פלט
Trying 127.0.0.1...
telnet: Unable to connect to remote host: Connection refused

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

חיבור שנסגר נראה אחרת: telnet כותב Connection closed by foreign host. ומחזיר את שורת הפקודה, כמו בסוף הדוגמאות בחלק הבא.

יש שירותים שלא מחכים, אלא פותחים בעצמם בשורת ברכה שנקראת banner. מה מקבלים כשמכוונים telnet לפורט 22 של מכונה עם OpenSSH?

Text
$ 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 עבר לשם
שני גבולות של הבדיקה. היא מתאימה רק ל-TCP: ב-UDP אין חיבור שאפשר לפתוח, ולכן telnet לא יגיד דבר על פורט UDP. והיא לא בודקת ping: מכונה שמתעלמת מ-ping עדיין יכולה לקבל חיבורים בפורט, וגם המצב ההפוך אפשרי.
תרחיש 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 במקום מהמקלדת):

Bash
{ printf 'GET /index.html HTTP/1.0\n\n'; sleep 1; } | telnet 127.0.0.1 8088
פלט
Trying 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 מעביר אותה לשרת בלי שום בדיקה, והשרת הוא שמחזיר שגיאה:

Bash
{ printf 'GIMME /index.html HTTP/1.0\n\n'; sleep 1; } | telnet 127.0.0.1 8088 2>&1 | head -4
פלט
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
HTTP/1.0 501 Unsupported method ('GIMME')

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

Text
$ 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לא
לתרגם שם לכתובת IPDNSלא
לבדוק אם פורט 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. ההצפנה שלו מכסה את החיבור כולו, ההזדהות, הסיסמה, הפקודות והפלט, ולא רק את שלב הכניסה. הוא עובד גם על פני האינטרנט הציבורי ולא רק ברשת מקומית, ואין לו קשר לניהול תיבות דואר.

Bash
ssh maya@build.lab.internal
TelnetSSH
פורט2322
הצפנהאיןכל החיבור, מקצה לקצה
מה רואה מאזיןהכול, כולל הסיסמהאת שורות הזיהוי, את בחירת האלגוריתמים ואת החלפת המפתחות בתחילת החיבור, וגם כתובות, פורטים, נפח ותזמון. כל מה שאחרי החלפת המפתחות, כולל הסיסמה, הפקודות והפלט, מוצפן
מהירות ומספר חיבוריםלא אלה היתרון של SSH: הוא לא מהיר יותר ולא מרשה יותר חיבורים בו זמניתהיתרון שלו הוא אבטחה
יכולות נוספותאיןהעברת קבצים מוצפנת (SCP, SFTP), מנהרות ו-Port Forwarding, תוכנות גרפיות מרחוק (X11 Forwarding), הזדהות בזוג מפתחות במקום סיסמה

כל אחת מהיכולות הנוספות מקבלת חלק משלה בהמשך הפרק.

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

מה קורה בלחיצת היד של SSH

עוד לפני שמופיעה שורת הפקודה, הלקוח והשרת עוברים שלב תיאום שנקרא Handshake:

  1. כל צד שולח שורת זיהוי (banner), למשל SSH-2.0-OpenSSH_8.9p1, בלי הצפנה.
  2. הצדדים מסכמים באילו אלגוריתמים ישתמשו (הודעת KEXINIT). גם זה עובר גלוי, ומאזין יכול לקרוא בו שמות כמו curve25519-sha256 ו-ssh-ed25519.
  3. מתבצעת החלפת מפתחות, והשרת חותם עליה במפתח המארח (Host Key) שלו. החתימה היא ההוכחה שהוא אכן השרת שהוא טוען להיות. גם ההודעות של שלב זה עוברות לפני שיש הצפנה, אבל מתוך מה שגלוי בהן אי אפשר לחשב את המפתחות שייווצרו.
  4. ההחלפה נחתמת בהודעה NEWKEYS, ומכאן נוצר ערוץ מוצפן: כל מה שעובר אחריה מוצפן.
  5. רק בתוך הערוץ הזה המשתמש מזדהה, בסיסמה או במפתח פרטי.

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

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

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

שלב 3 מעלה שאלה: איך הלקוח יודע שהחתימה שייכת לשרת הנכון? כאן SSH הולך בדרך שונה מזו של HTTPS:

HTTPSSSH, כברירת מחדל
מי מעיד על זהות השרתרשות אישורים (CA) שחתמה על התעודה של האתרהלקוח עצמו, שזוכר את מפתח המארח
איפה נשמר מה שסומכים עליורשימת רשויות שמותקנת בדפדפןהקובץ known_hosts אצל הלקוח
חזרה לתוכן העניינים

מפתח המארח והקובץ known_hosts

השרת מזדהה בעזרת זוג מפתחות שנוצר עבורו, בדרך כלל בהתקנה, ונשמר אצלו. את החצי הפרטי הוא לא מראה לאף אחד, ואת החצי הציבורי, מפתח המארח (Host Key), הוא מציג בכל חיבור כמו תעודת זהות.

טביעת אצבע (fingerprint) היא תקציר קצר של המפתח הזה, שנוח להשוות בעיניים. כך היא נראית למפתח Ed25519 שיצרנו לשרת בדיקה:

Bash
ssh-keygen -lf hostkey.pub
פלט
256 SHA256:CwMQHC+lS/HpYLsNaggYnzDlVNfsQzfpJPMBIDueMVY no comment (ED25519)

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

Text
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 ומשווה את המפתח שהוצג לרשום. כשאין התאמה, הוא עוצר בהודעה בולטת ולא מתחבר, עד שהשורה הישנה נמחקת או מתעדכנת:

Text
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

את השורה הישנה מסירים בפקודה ssh-keygen -R. בדוגמה הבאה בודקים קודם שהשרת רשום (-F), ואז מוחקים אותו. הדגל -f מכוון לקובץ known_hosts מסוים, ובלעדיו הפקודה עובדת על ~/.ssh/known_hosts:

Bash
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 בלי להקליד סיסמה. את הזוג מייצרים בצד הלקוח, ורק החצי הציבורי עובר לשרת.

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

ssh-keygen מייצר את הזוג, ssh-copy-id מתקין את החצי הציבורי

את הזוג מייצרים בפקודה ssh-keygen, והדגל -t בוחר את סוג המפתח. ההרצה הרגילה היא ssh-keygen -t ed25519, והיא שומרת את שני הקבצים בתיקייה ~/.ssh של המשתמש בשמות id_ed25519 ו-id_ed25519.pub.

בניסוי שלמטה הפנינו את הקבצים לתיקיית ניסוי בשם lab בעזרת -f, ו--N "" מוותר על משפט סיסמה למפתח, כדי שההרצה לא תעצור לשאלות:

Bash
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 key
פלט
id_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 עושה את כל העבודה בפקודה אחת:

Bash
ssh-copy-id -i ~/.ssh/id_ed25519.pub omer@backup.example.net
  • הוא מתחבר לשרת בחיבור SSH רגיל, ובדרך כלל זו הפעם האחרונה שתתבקשו להקליד את הסיסמה.
  • הוא מוסיף את המפתח הציבורי לסוף הקובץ ~/.ssh/authorized_keys של החשבון בשרת.
  • הוא מוודא שלתיקייה ולקובץ יש הרשאות (permissions) מתאימות, כי שרת SSH מתעלם מקובץ מפתחות שאחרים יכולים לכתוב אליו.

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

חשוב לדעת גם מה הכלי לא עושה. הוא מעביר רק את החצי הציבורי ולעולם לא את הפרטי, הוא לא מייצר מפתחות (זה התפקיד של ssh-keygen בלקוח), והוא לא כותב שום דבר ל-known_hosts.

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

מה עובר ברשת כשמתחברים במפתח

  1. הלקוח מודיע לשרת באיזה מפתח ציבורי הוא רוצה להשתמש.
  2. השרת מוצא את המפתח הזה ב-authorized_keys של החשבון ומציב אתגר (challenge): נתון חד פעמי שהלקוח צריך לחתום עליו. בפרוטוקול עצמו האתגר נגזר ממזהה הסשן שנקבע בלחיצת היד, ולכן הוא שונה בכל חיבור.
  3. הלקוח חותם על האתגר בעזרת המפתח הפרטי ושולח רק את החתימה.
  4. השרת בודק את החתימה בעזרת המפתח הציבורי שכבר שמור אצלו. אם היא תקינה, המשתמש בפנים.

אפשר לראות את העיקרון הזה בעבודה בעזרת יכולת החתימה של ssh-keygen (הדגל -Y, זמין מ-OpenSSH 8.1). זה לא פרוטוקול ההתחברות עצמו, אבל זו אותה פעולה: חתימה במפתח הפרטי ובדיקה במפתח הציבורי בלבד.

Bash
# 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.sig
פלט
Good "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 ונשווה גדלים:

Bash
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: שרת גיבויים בלי הקלדת סיסמה

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

  1. במחשב שלו הוא מריץ ssh-keygen -t ed25519. נוצרים id_ed25519, שנשאר אצלו, ו-id_ed25519.pub, שמיועד לשרת.
  2. הוא מריץ ssh-copy-id omer@backup.example.net, מקליד את הסיסמה פעם אחרונה, והכלי מוסיף את הציבורי ל-authorized_keys בשרת ומסדר את ההרשאות.
  3. מעכשיו 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, -YX11 Forwarding, כש-Y נותן לתוכנה המרוחקת אמון רחב יותר.
-AAgent Forwarding.
-Jמתחבר דרך שרת ביניים (Jump Host).

שלושה זוגות שבהם הכי קל להתבלבל:

  • -C (דחיסה) מול -c (בחירת cipher).
  • -p קטנה בפקודה ssh מול -P גדולה בפקודות scp ו-sftp, ובשני המקרים מדובר בפורט.
  • -f (רקע) מול -N (בלי פקודה מרוחקת). כל אחד לבד לא מספיק למנהרה שקטה, ולכן משלבים אותם: -fN.

אפשר לבדוק איך ssh הבין את הדגלים בלי להתחבר לשום מקום: הדגל -G מדפיס את ההגדרות שהיו בתוקף לחיבור ויוצא. כאן רואים ש-C הגדולה הדליקה דחיסה ו-c הקטנה רק קבעה cipher:

Bash
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

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

Bash
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, וההבדל ביניהם הוא במה שהם יודעים לעשות.

נושאSCPSFTP
ייעודהעתקה חד-פעמית של קבציםניהול קבצים בשרת מרוחק
מה אפשר לעשותלהעתיק, וזהולרשום תוכן תיקייה, לשנות שם, למחוק, לשנות הרשאות ולחדש העברה שנקטעה
הצפנהמוצפן, כי הוא רץ בתוך SSHמוצפן, כי הוא רץ בתוך SSH
פורט22, כמו SSH22, כמו SSH. אין קשר ל-FTP ולפורט 21
כיווןהעלאה לשרת והורדה ממנוהעלאה לשרת והורדה ממנו
דגל הפורט-P גדולה-P גדולה
Bash
# 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 חלה על הדרך בלבד: ברגע שהקובץ נחת בשרת, הוא יושב בדיסק כמו כל קובץ אחר, בלי הצפנה מיוחדת. ולרשימת כלי ההעברה לא שייכים ssh-keygen, שכל תפקידו לייצר מפתחות, ו-cron, מתזמן המשימות של מערכת ההפעלה, שאינו חלק מ-SSH בכלל.
תרחיש 10: קובץ אחד היום, ניהול תיקייה מחר

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

  1. להעלאה החד-פעמית של היום מספיק scp.
  2. לרשימת התיקייה, לשינוי השם ולמחיקה היא צריכה 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 מובילה תעבורה של תוכנות אחרות דרך החיבור המוצפן שכבר פתוח. בעזרתה מצפינים שירות שאינו מצפין בעצמו, או מגיעים לשירות שאינו חשוף לכם ישירות.

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

דגלשםהפורט המאזין נפתחהתעבורה מגיעה אל
-LLocalבמחשב שלכם (הלקוח)יעד אחד קבוע, כפי שהשרת רואה אותו
-RReverseבשרת המרוחקיעד אחד קבוע, כפי שהמחשב שלכם רואה אותו
-DDynamicבמחשב שלכםכל יעד שהתוכנה מבקשת, דרך פרוקסי SOCKS

גם כאן -G מראה איך ssh פירש את הדגלים בלי להתחבר בפועל:

Bash
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.

Bash
# 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 ביעד מתפרשת בצד של שרת הדואר, כלומר השרת עצמו:

Bash
ssh -L 2143:localhost:143 ella@mail.harbor.example

בתוכנת הדואר מגדירים שרת IMAP בכתובת localhost ובפורט 2143. התעבורה נכנסת למנהרה ויוצאת ממנה אל פורט 143 בשרת הדואר, ובדרך היא מוצפנת.

תרחיש 11: לוח הבנייה הפנימי מהבית

לוח הבנייה ci-board של החברה זמין רק מתוך הרשת הפנימית. מהאינטרנט פתוח רק שרת SSH אחד בשם bastion, ומ-bastion אפשר להגיע ל-ci-board.

  1. אבי מריץ בבית ssh -L 9000:ci-board:8080 avi@bastion.example.com ומזדהה.
  2. במחשב הביתי שלו נפתח פורט 9000 שמאזין.
  3. בדפדפן הוא פותח את http://localhost:9000.
  4. הבקשה נכנסת למנהרה, מגיעה ל-bastion, ומשם יוצאת אל ci-board:8080.

-R היה פותח את הפורט ב-bastion ולא בבית, -D היה מקים פרוקסי בלי יעד קבוע, ו--p משנה רק את פורט היעד של חיבור ה-SSH עצמו.

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

Reverse Port Forwarding: ssh -R

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

Bash
# 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 הוא עצמו פתח כלפי חוץ. החיבורים הנכנסים מגיעים אליו בתוך החיבור שכבר קיים.

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

כדי לזכור: L מאזין במחשב שלכם, R מאזין בצד של השרת. ודגלים אחרים לא עושים את זה: -N רק מוותר על פקודה מרוחקת, -C דוחס ו--J מתחבר דרך שרת ביניים.

תרחיש 12: להראות לעמית אפליקציה שרצה על הלפטופ

טל מפתחת אפליקציה שרצה על הלפטופ שלה בפורט 5000, מאחורי NAT ביתי. עמית שעובד על relay.example רוצה לנסות אותה.

  1. טל מריצה ssh -R 7000:localhost:5000 tal@relay.example.
  2. ב-relay.example נפתח פורט 7000 שמאזין.
  3. העמית, שמחובר ל-relay.example, פונה ל-localhost:7000, והחיבור יורד במנהרה אל פורט 5000 בלפטופ של טל.

הפורט זמין רק מתוך relay.example עצמו, כי הוא קשור ל-loopback. אם רוצים לחשוף אותו מעבר לכך, צריך GatewayPorts.

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

פרוקסי דינמי: ssh -D

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

Bash
# 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 חותם בשמכם.

Bash
ssh -A dana@jump-a
# now on jump-a: the signature request goes back to the agent on the laptop
ssh dana@db-b

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

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

שני מנגנונים עם שם דומה עושים דברים אחרים לגמרי:

  • Port Forwarding מעביר דרך חיבור ה-SSH תעבורת רשת של תוכנות אחרות.
  • ControlMaster פותח חיבור ראשי אחד, וכל פקודת ssh נוספת לאותו שרת רוכבת עליו במקום להתחבר מחדש, ולכן היא עולה כמעט מיד.

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

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

X11 Forwarding

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

Bash
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 מדליקים בדיוק את שתי ההעברות האלה, שכבויות כברירת מחדל:

Bash
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 ידבר דרכה. החופש הזה גמיש יותר, ובתמורה דורש הגדרה ידנית מפורטת.
Text
# 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@edge1

ProxyJump שקול ל-ProxyCommand שמריץ ssh -W, רק בתחביר קצר שמכסה את המקרים הנפוצים. כך ssh קורא את השרשרת:

Bash
ssh -G -J rina@edge1,rina@edge2 rina@vault | grep ^proxyjump
פלט
proxyjump 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 מה נכנס לתוקף:

Bash
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 משמש כאן כקובץ הגדרות ריק:

Bash
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-passwordroot נכנס במפתח בלבד. בסיסמה הוא נחסם
forced-commands-onlyroot נכנס במפתח, ורק כדי להריץ פקודה אחת שהוגדרה מראש
noאף כניסה ישירה כ-root, בשום שיטת הזדהות

בהקשחה בוחרים בדרך כלל no. אחריו אין מבחוץ חשבון root שאפשר לנחש לו סיסמה, ומי שצריך הרשאות מנהל נכנס בשם המשתמש שלו ועובר ל-root עם sudo.

שאר הערכים בטבלה משאירים ל-root דרך להיכנס ישירות. prohibit-password ו-forced-commands-only מצמצמים אותה לכניסה עם מפתח, ו-yes לא מצמצם דבר ומשאיר את כל הדלתות פתוחות.

Text
# /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 לפורט אחר. סורקים אוטומטיים באינטרנט מנסים קודם כול את הפורט המוכר, ולכן במקום אחר מגיעים הרבה פחות ניסיונות התקפה אוטומטיים.

זו אבטחה דרך הסתרה (Security by obscurity), לא תחליף להגדרות חזקות. שינוי הפורט לא מצפין כלום, לא חוסם כתובות ולא מוריד את הצורך בהזדהות. משלבים אותו עם הזדהות במפתחות ועם הגבלה של מי רשאי להתחבר.
תרחיש 14: החיבור נופל בכל הפסקת קפה

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

  1. בזמן ההפסקה לא עוברת תעבורה, ורכיב ה-NAT של הספק מסיק שהחיבור נטוש ומוחק אותו מהטבלה.
  2. יואב מוסיף ל-~/.ssh/config את השורה ServerAliveInterval 45.
  3. מעכשיו, אחרי 45 שניות של שקט, הלקוח שולח הודעה קטנה בתוך החיבור. ה-NAT רואה תעבורה, והחיבור שורד.

ההגדרה הזו שייכת ללקוח. ב-sshd_config ההגדרה המקבילה, שבה השרת הוא ששולח, היא ClientAliveInterval.

תרחיש 15: הקשחה של שרת שחוטף ניסיונות ניחוש

ביומן של שרת ה-SSH יש אלפי ניסיונות כניסה כושלים ביום, ומירה רוצה לצמצם את הסיכון.

  1. ב-sshd_config היא קובעת PermitRootLogin no, ו-root כבר לא יכול להתחבר ישירות.
  2. היא מקטינה את MaxAuthTries ומקצרת את LoginGraceTime, וכך כל חיבור מקבל מעט ניסיונות וזמן קצר.
  3. היא עוברת להזדהות במפתחות ומשאירה ב-AllowUsers רק את המשתמשים שצריכים גישה.
  4. בנוסף היא מעבירה את השרת לפורט אחר. זה מוריד את הרעש של סורקים אוטומטיים, אבל אינו הגנה של ממש.
טעויות נפוצות
  • 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 לגמרי, ושינוי פורט רק מוריד רעש של סורקים.

השוואה אחרונה בין שני הכלים לגישה מרחוק:

נושאTelnetSSH
פורט23, מעל TCP22, מעל 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
הצפנה אינה משהו ש-TCP נותן: Telnet רץ על TCP ולא מצפין דבר. ב-SSH הערוץ מוצפן כבר לפני שלב ההזדהות, ולכן גם הסיסמה עוברת מוצפנת, ולא רק מה שבא אחריה.
פורטשירות
22SSH, וגם SCP ו-SFTP
23Telnet
25SMTP, שליחת דואר
80HTTP
110POP3
143IMAP, בגלוי או עם STARTTLS
443HTTPS
993IMAPS, כלומר IMAP מעל TLS
995POP3 מעל TLS
תרחיש 16: שתי התחברויות לאותו מתג, שתי תמונות שונות

מנהלת הרשת פותחת ב-Wireshark הקלטה שיש בה שתי התחברויות למתג אחד: אחת ב-Telnet לפורט 23, ואחת ב-SSH לפורט 22. על כל אחת היא מריצה Follow TCP Stream.

  1. בהתחברות ה-Telnet שום דבר לא מוצפן, ולכן שם המשתמש והסיסמה מופיעים כטקסט רגיל.
  2. בהתחברות ה-SSH הערוץ הוצפן עוד לפני שלב ההזדהות, ולכן הסיסמה לא קריאה.
  3. בשיחת ה-SSH הדבר היחיד שאפשר לקרוא הוא שורת הגרסה שבפתיחה.

המסקנה: Telnet חושף את פרטי ההתחברות לכל מי שמאזין, ו-SSH לא. זו סיבה מספיקה לוותר על Telnet ולעבור ל-SSH בשרתי ייצור.

בדקו את עצמכם
באילו פורטים עובדים כברירת מחדל SSH, Telnet ו-IMAP מוצפן?

SSH ב-22, Telnet ב-23, ו-IMAPS ב-993.

במה שונה Follow TCP Stream על בקשה ב-HTTP רגיל מאותה פעולה על חיבור SSH?

ב-HTTP רגיל כל הבקשה קריאה. ב-SSH התוכן מוצפן, ורק שורת הגרסה בתחילת השיחה גלויה.