הבנת תקעים

הקדמה

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

קפיצות רשת בשני הצדדים, הלקוח והשרת, מתייחסות לכתובת ה-קפיצות. כתובת היא שילוב ייחודי של פרוטוקול תקשורת כמו פרוטוקול בקרת התקשורת (TCP) או פרוטוקול חבירת המידע (UDP), כתובת IP, ומספר יציאה.

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

• קפיצות זרם, שמשתמשות ב־TCP כפרוטוקול התקשורת התחתון שלהן
• קפיצות דטגרם, שמשתמשות ב־UDP כפרוטוקול התקשורת התחתון שלהן
• קפיצות דומיין Unix, שמשתמשות בקבצים מקומיים כדי לשלוח ולקבל נתונים במקום ממשקי רשת וחבילות IP.

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

דרישות מוקדמות

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

כדי להתחיל בשימוש ב-Ubuntu 20.04, תצטרך שרת אחד שהוגדר באמצעות מעקב אחרי המדריך שלנו להגדרת השרת הראשונית עבור Ubuntu 20.04.

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

sudo apt update 

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

sudo apt install iproute2 netcat-openbsd socat

חבילת iproute2 מכילה את התועלת ss, שזו התועלת שנשתמש בה כדי לבדוק קפיצים. נשתמש בחבילת netcat-openbsd כדי להתקין את netcat. שים לב ש-netcat מקוצר ל-nc כאשר זה מופעל בשורת הפקודה. לבסוף, נשתמש בחבילת socat כדי ליצור קפיצים דוגמתיים.

מהו קפיץ זרם?

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

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

A typical use for a TCP-based stream socket would be for a web server like Apache or Nginx handling HTTP requests on port 80, or HTTPS on port 443. For HTTP, a socket address would be similar to 203.0.113.1:80, and for HTTPS it would be something like 203.0.113.1:443.

יצירת קיפוסי זרם בשימוש בתקשורת TCP

בדוגמה הבאה תשתמש בפקודת socat (ראשי תיבות של SOcket CAT) כדי להדמות שרת אינטרנט המאזין לבקשות HTTP על פתח 8080 (פורט HTTP אלטרנטיבי). לאחר מכן תבחן את הקיפוס באמצעות הפקודות ss ו־nc.

ראשית, הפעל את הפקודות הבאות של socat כדי ליצור שני קיפוסי זרם מבוססי TCP המאזינים לחיבורים על פורט 8080, באמצעות ממשקי IPv4 ו־IPv6:

socat TCP4-LISTEN:8080,fork /dev/null&
socat TCP6-LISTEN:8080,ipv6only=1,fork /dev/null&

• הארגומנטים TCP4-LISTEN:8080 ו־TCP6-LISTEN:8080 הם סוג הפרוטוקול ומספר הפורט לשימוש. הם אומרים ל־socat ליצור גלילות TCP בפורט 8080 על כל ממשקי ה־IPv4 וה־IPv6, ולהאזין לכל גליל עבור חיבורים נכנסים. socat יכול להאזין לכל פורט זמין במערכת, כך שכל פורט בין 0 ל־65535 הוא פרמטר חוקי עבור אפשרות הגליל.
• אפשרות ה־fork משמשת כדי לוודא ש־socat ממשיך לרוץ לאחר שהוא מטפל בחיבור, אחרת הוא היה יצא אוטומטית.
• הנתיב /dev/null משמש במקום כתובת גליל מרוחקת. במקרה זה הוא אומר ל־socat להדפיס כל קלט נכנס לקובץ /dev/null, שמשכפל אותו בשקט.
• הדגל ipv6only=1 משמש לגליל IPv6 כדי להודיע למערכת ההפעלה שהגליל אינו מוגדר לשלוח חבילות אל כתובות IPv4 באמצעות IPv6. בלעדיו, socat יחבור לשני כתובות IPv4 ו־IPv6.
• התו & מורה למפרש להריץ את הפקודה ברקע. דגל זה יוודא ש־socat ממשיך לרוץ בזמן שאתה קורא פקודות נוספות כדי לבדוק את הגליל.

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

Output
[1] 434223
[2] 434224

עכשיו שיש לך שני תהליכי socat המאזינים ברקע בפתחת TCP 8080, ניתן לבדוק את הקפיצים באמצעות הכלים ss ו־nc.

בדיקת קפיצים מבוססי TCP

כדי לבדוק קפיצים TCP במערכת Linux מודרנית באמצעות הפקודה ss, הפעל אותה עם האפשרויות הבאות כדי להגביל את הפלט:

• האפשרויות -4 ו־-6 אומרות ל־ss לבדוק רק קפיצים IPv4 או IPv6 בהתאמה. פילוט אפשרות זו יציג את שני סטים השל קפיצים.
• האפשרות t מגבילה את הפלט לקפיצים TCP. כברירת מחדל, כל סוגי הקפיצים בשימוש במערכת Linux יוצגו בעזרת הכלי ss.
• האפשרות l מגבילה את הפלט לקפיצים המאזינים. בלעדיו, כל החיבורים TCP היו יוצגים, כולל דברים כמו SSH, לקוחות שעשויים להיות מחוברים לשרת אינטרנט, או חיבורים שיש למערכת שלך לשרתים אחרים.
• האפשרות n מבטיחה שמספרי הפורט יוצגו במקום שמות השירותים.

הרץ תחילה את הפקודה ss -4 -tln כדי לבדוק את הקפיצים מבוססי TCP של IPv4 שמאזינים לחיבורים במערכת שלך:

ss -4 -tln

תקבל פלט דומה למקרה הבא:

Output
State      Recv-Q     Send-Q         Local Address:Port           Peer Address:Port     Process     
. . .
LISTEN     0          1                    0.0.0.0:8080                  0.0.0.0:*
. . .

יתכן ויהיו שורות נוספות עם יציאות אחרות בפלט שלך בהתאם לשירותים שפועלים במערכת שלך. החלק שמסומן 0.0.0.0:8080 בפלט מציין שתקף ה-Socket TCP של IPv4 מאזין לכל ממשקי ה-IPv4 הזמינים בפורט 8080. שירות שמאזין רק לכתובת IPv4 מסוימת יציג רק את ה-IP הזה בשדה המסומן, לדוגמה 203.0.113.1:8080.

כעת הרץ את אותו פקודת ss שוב אך עם הדגל -6:

ss -6 -tln

תקבל פלט כגון הבא:

Output
State    Recv-Q   Send-Q     Local Address:Port     Peer Address:Port  Process  
. . .
LISTEN   0        5                   [::]:8080               [::]:*
. . .

יתכן ויהיו שורות נוספות עם יציאות אחרות בפלט שלך בהתאם לשירותים שפועלים במערכת שלך. החלק שמסומן [::]:8080 בפלט מציין שתקף ה-Socket TCP של IPv6 מאזין לכל ממשקי ה-IPv6 הזמינים בפורט 8080 (כפי שמצויין על ידי התווים ::, שהם רמזורים של IPv6 עבור כתובת שמורכבת מאפסים בלבד). שירות שמאזין רק לכתובת IPv6 מסוימת יציג רק את ה-IP הזה בשדה המסומן, לדוגמה [2604:a880:400:d1::3d3:6001]:8080.

חיבור ל-Sockets בהתבסס על TCP

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

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

כדי להתחבר לקצה הסוקט IPv4 על ידי כתובת לולאה מקומית באמצעות netcat, הפעל את הפקודה הבאה:

nc -4 -vz 127.0.0.1 8080

• הדגל -4 אומר ל־netcat להשתמש ב־IPv4.
• הדגל -v משמש להדפסת פלט מפורט לטרמינל שלך.
• האפשרות –z מבטיחה ש־netcat רק יתחבר לסוקט, בלי לשלוח נתונים.
• הכתובת IP של לולאת המעגל המקומית 127.0.0.1 משמשת מאחר ולמערכת שלך יש כתובת IP ייחודית משלה. אם ידועה לך הכתובת IP של המערכת שלך, באפשרותך לבדוק באמצעותה גם כן. לדוגמה, אם כתובת ה־IP הציבורית או הפרטית של המערכת שלך היא 203.0.113.1, אפשר להשתמש בה במקום כתובת ה־IP של לולאת המעגל.

תקבל פלט כמו הבא:

Output
Connection to 127.0.0.1 (127.0.0.1) 8080 port [tcp/http-alt] succeeded!

השורה המודגשת היא פלט מ־netcat. היא מציינת ש־netcat מחוברת לסוקט TCP שמאזין על כתובת IPv4 של לולאת המעגל בפורט 8080. ניתן להתעלם מהשורה השנייה, היא מתהליך socat שפועל ברקע בטרמינל שלך.

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

nc -6 -vz ::1 8080

תקבל פלט כמו הבא:

Output
Connection to ::1 8080 port [tcp/http] succeeded!

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

כדי לנקות את הקפיצים שלך, תצטרך להפעיל את הפקודה fg (foreground) עבור כל תהליך socat שיצרת. לאחר מכן, תשתמש ב-CTRL+C כדי לסגור את כל socat. fg יביא תהליכים לרקע של הטרמינל שלך בסדר הפוך שבו הפעלת אותם, כך שכאשר אתה מפעיל אותו, תהליך socat השני יהיה אליו אתה מתקשר ראשון.

הפעל את fg כדי להביא את תהליך socat IPv6 השני לרקע של הטרמינל שלך. לאחר מכן הפעל את CTRL+C כדי לסגור אותו.

fg

תקבל פלט דומה למה שלמטה:

Output
socat TCP6-LISTEN:8080,ipv6only=1,fork /dev/null

לחץ CTRL+C כדי לעצור את התהליך.

עכשיו הפעל שוב את fg כדי לנקות את תיבת הקפיצים הראשונה של IPv4. עליך לקבל פלט דומה למה שלמטה:

Output
socat TCP4-LISTEN:8080,fork /dev/null

לחץ CTRL+C כדי לעצור את התהליך.

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

מהו קפיץ Datagram?

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

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

קצוות UDP בדרך כלל משמשים על ידי שרתי מערכת שם דומיין (DNS). לפי ברירת המחדל, שרתי DNS משתמשים ביציאה 53 כדי לשלוח ולקבל שאילתות עבור שמות דומיין. כתובת קצה של קצה UDP עבור שרת DNS יכולה להיות דומה ל- 203.0.113.1:53.

פרוטוקול הזמן ברשת (NTP) משתמש בקצה UDP ביציאה 123 כדי לסנכרן שעונים בין מחשבים. דוגמה לקצה UDP עבור פרוטוקול NTP היא 203.0.113.1:123.

יצירת קצוות דטה-גראם

כמו בדוגמה הקודמת של כסיכת TCP, בסעיף זה תשתמש שוב ב־socat כדי להדמות שרת NTP המקשיב לבקשות בפורט UDP 123. לאחר מכן תבדוק את הקצוות שאתה יוצר באמצעות הפקודות ss ו־nc.

ראשית, הרץ את הפקודות socat הבאות כדי ליצור שני קצוות UDP המקשיבים לחיבורים בפורט 123, באמצעות ממשקי IPv4 ו־IPv6:

sudo socat UDP4-LISTEN:123,fork /dev/null&
sudo socat UDP6-LISTEN:123,ipv6only=1,fork /dev/null&

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

Output
[1] 465486
[2] 465487

• כל פקודה מתחילה ב־sudo, מאחר ופורטים מ־0 עד 1024 רזרווידים ברוב המערכות. sudo מפעיל פקודה עם הרשאות מנהל, מה שמאפשר ל־socat לקשור לפורט בטווח המורשה.
• הארגומנטים UDP4-LISTEN:123 ו־UDP6-LISTEN:123 הם סוג הפרוטוקול והפורט לשימוש. הם מודיעים ל־socat ליצור קצוות מבוססי UDP בפורט 123 על ידי ממשקי IPv4 ו־IPv6, ולהאזין לנתונים נכנסים. שוב, כל פורט בטווח המלא של 0-65535 הוא פרמטר חוקי עבור קצוות UDP.
• הארגומנטים fork, ipv6only=1, ו־/dev/null משמשים באותה הדרך כמו שתואר בדוגמה הקודמת של TCP.

עכשיו שיש לך שני תהליכי socat המאזינים בפורט UDP 123, אתה יכול לבדוק את הקצוות באמצעות כלי ה־ss ו־nc.

בדיקת תקשורת דגימה

כדי לבדוק תקשורת דגימה (UDP) במערכת Linux מודרנית באמצעות הפקודה ss, יש להפעיל אותה עם הדגלים הבאים -4, -6, ו־uln כדי להגביל את הפלט:

הדגל u מגביל את הפלט לקצוות UDP.
הדגלים האחרים זהים לאלו שנעשה שימוש בדוגמה הקודמת של TCP.

ראשית, הפעילו את הפקודה ss -4 -uln כדי לבדוק את הקצוות UDP של IPv4 המאזינים לחיבורים במערכת שלכם:

ss -4 -uln

תקבלו פלט דומה לזה שלמטה:

Output
State      Recv-Q     Send-Q         Local Address:Port           Peer Address:Port     Process     
. . .
UNCONN   0        0                 0.0.0.0:123            0.0.0.0:*
. . .

ייתכן כי יהיו שורות אחרות עם פורטים אחרים בפלט שלך תלוי בשירותים שפועלים במערכת שלך. החלק המסומן 0.0.0.0:123 של הפלט מציין שקצה ה־UDP של IPv4 זמין על כל ממשקי ה־IPv4 בפורט 123. שירות שזמין רק בכתובת IPv4 מסוימת יציג רק את כתובת ה־IP הזו בשדה המסומן, לדוגמה 203.0.113.1:123.

כעת הפעילו שוב את הפקודה ss אך עם הדגל -6:

ss -6 -uln

תקבלו פלט דומה לזה שלמטה:

Output
State    Recv-Q   Send-Q     Local Address:Port     Peer Address:Port  Process  
. . .
UNCONN   0        0                   [::]:123              [::]:*
. . .

יתכן וישנם שורות אחרות עם פורטים אחרים בפלט שלך תלוי בשירותים שרצים על המערכת שלך. החלק המודגש [::]:123 של הפלט מציין כי גלגל TCP של IPv6 זמין על כל ממשקי ה-IPv6 בפורט 123 (כפי שמצויין על ידי התווים ::). שירות שזמין רק על כתובת IPv6 מסוימת יציג רק את כתובת ה-IP הזו בשדה המודגש, לדוגמה [2604:a880:400:d1::3d3:6001]:123.

בדיקת גלגלי דאטגראם

עכשיו שאתה מכיר באופן בו ניתן ליצור ולרכז גלגלי UDP בממשקי IPv4 ו-IPv6, אתה יכול לנסות לחבר אליהם. כמו גם עם גלגלי TCP, אתה יכול לנסות גלגלי UDP באמצעות כלי ה-netcat.

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

nc -4 -u -vz 127.0.0.1 123

• הדגל -4 מספר ל-netcat להשתמש ב-IPv4.
• האפשרות -u מציינת ל-netcat להשתמש ב-UDP במקום ב-TCP.
• הדגל -v משמש להדפסת פלט מפורט בטרמינל שלך.
• האפשרות -z מבטיחה ש-netcat יתחבר רק לגלגל, מבלי לשלוח נתונים.
• כתובת ה־IP לופבק מקומית 127.0.0.1 משמשת מאחר ולמערכת שלך ישנה כתובת IP ייחודית משלה. אם אתה מכיר את כתובת ה־IP של המערכת שלך, תוכל לבדוק את זה גם עם זאת. לדוגמה, אם כתובת ה־IP הציבורית או הפרטית של המערכת שלך היא 203.0.113.1, תוכל להשתמש בכך במקום כתובת ה־IP של ה־loopback.

תקבל פלט דומה למה שלמטה:

Output
Connection to 127.0.0.1 123 port [udp/ntp] succeeded!

הפלט מציין ש־netcat לא קיבלה שגיאה מהסוקט UDP שקשור ל־loopback 127.0.0.1 על פתח 123. העדר תגובת שגיאה זו משמשת להסקת שהסוקט ב־127.0.0.1:123 זמין. התנהגות זו שונה מסוקטים TCP, שדורשים החלפת חבילות כדי לאמת אם סוקט זמין.

כעת, תוכל לחזור על אותו מבחן חיבור אך עם שימוש ב־IPv6. הרץ את הפקודה netcat הבאה:

nc -6 -u -vz ::1 123

תקבל פלט דומה למה שלמעלה:

Output
Connection to ::1 123 port [udp/ntp] succeeded!!

הפלט מציין ש־netcat לא קיבל שגיאה מתוך כניסת תקשורת UDP המאזינה על כתובת ה־IPv6 של הלולאה בפורט 123. שוב, העדר תגובת שגיאה משמש להסקת שהכניסה ב־::1:123 זמינה.

כדי לנקות את הכניסות שלך, תצטרך להריץ את הפקודה fg (רקע) עבור כל תהליך socat שיצרת. לאחר מכן תשתמש ב־CTRL+C כדי לסגור כל socat.

הפעל את fg כדי להביא את תהליך socat ה־IPv6 השני לרקע של הטרמינל שלך. לאחר מכן הפעל את CTRL+C כדי לסגור אותו.

fg

תקבל פלט כמו בדוגמה הבאה:

Output
sudo socat UDP6-LISTEN:123,ipv6only=1,fork /dev/null

לחץ CTRL+C כדי לעצור את התהליך.

עכשיו הפעל fg שוב כדי לנקות את כניסת ה־IPv4 הראשונית. תקבל פלט כמו בדוגמה הבאה:

Output
sudo socat UDP4-LISTEN:123,fork /dev/null

לחץ CTRL+C כדי לעצור את התהליך.

יצרת, בדקת ובדקת כניסות UDP של IPv4 ו־IPv6 במערכת שלך. נסה להתנסות עם כל הכלים כדי להכיר יותר איך הם יכולים לשמש לבדיקה ולפתרון בעיות בכניסות UDP.

מהו כניסת מתוך מערכת Unix?

תוכניות שרצות על אותו שרת יכולות גם לתקשר אחת עם השנייה באמצעות קפיצי Unix Domain (UDS). קפיצי ה-Domain של Unix יכולים להיות מבוססי זרם, או מבוססי Datagram. בשימוש בקפיצי ה-Domain, מידע מוביל בין התוכניות ישירות בליבת מערכת ההפעלה דרך קבצים במערכת הקבצים של המארח. כדי לשלוח או לקבל מידע באמצעות קפיצי ה-Domain, תוכניות קוראות וכותבות לקובץ הקפיץ המשותף שלהן, ועוברות מעל קפיצי הרשת והפרוטוקולים לחלוטין.

קפיצי ה-Domain של Unix משמשים באופן רחב על ידי מערכות בסיסי נתונים שאינן צריכות להיות מחוברות לממשק רשת. לדוגמה, MySQL על Ubuntu ברירת המחדל משתמשת בקובץ בשם /var/run/mysqld/mysql.sock לתקשורת עם לקוחות מקומיים. לקוחות קוראים וכותבים לקפיץ, כמו גם השרת של MySQL עצמו.

PostgreSQL היא מערכת בסיס נתונים נוספת שמשתמשת בקפיץ לתקשורת מקומית ללא רשת. לרוב, המערכת משתמשת בברירת המחדל /run/postgresql/.s.PGSQL.5432 כקובץ הקפיץ שלה.

יצירת קפיצי Unix Domain

בקטעים הקודמים חקרת איך TCP משמש עם קצוות זרימה, ואיך UDP משמש עם קצוות דטגרמים. בקטע זה תשתמש ב־socat כדי ליצור גם קצוות Unix Domain Sockets מבוססי זרימה וגם קצוות Unix Domain Sockets מבוססי דטגרמים מבלי להשתמש ב־TCP או ב־UDP כדי להכליל נתונים לשליחה דרך רשתות. לאחר מכן תבחן את הקצוות שיצרת באמצעות הפקודות ss ו־nc. לבסוף, תלמד על בדיקת Unix Domain Sockets באמצעות netcat.

להתחלה, הריץ את הפקודות הבאות של socat כדי ליצור שני קבצי קצוות:

socat unix-listen:/tmp/stream.sock,fork /dev/null&
socat unix-recvfrom:/tmp/datagram.sock,fork /dev/null&

• הפקודה הראשונה מורה ל־socat ליצור קצה באמצעות סוג כתובת unix-listen, שתיצור UDS מבוסס זרימה.
• הפקודה השנייה מציין unix-recvfrom כסוג הקצה, שיצור UDS מבוסס דטגרמים.
• שתי הפקודות מציינות שם קובץ אחרי מפריד ה־:. שם הקובץ הוא כתובת הקצה עצמו של הקצה. בדוגמה הראשונית של זרימה הוא /tmp/stream.sock ובדוגמה השנייה של דטגרמים הוא /tmp/datagram.sock. שים לב ששם הקצה הוא ברירת המחדל אך זה עוזר כאשר אתה מפתר בעיות.
• הארגומנטים fork ו־/dev/null משמשים באותה הדרך כפי שנתאר בקטעי הדוגמה של קצוות זרימה ודטגרמים.

עכשיו שיצרת שני קצוות UDS שלך, אתה יכול לבחון אותם באמצעות הכלים ss ו־nc.

בדיקת קופסאות דומיין Unix

כדי לרשום את כל קופסאות הדומיין Unix ששומעות, הפעל את הפקודה ss -xln. הדגל x מבטיח שרק קופסאות הדומיין יוצגו.

ss -xln

תקבל פלט כזה:

Output
Netid State  Recv-Q Send-Q      Local Address:Port   Peer Address:Port  Process
. . .
u_str LISTEN 0      5        /tmp/stream.sock 436470            * 0             
u_dgr UNCONN 0      0      /tmp/datagram.sock 433843            * 0
 . . .

שים לב לחלק המודגש u_str של השורה /tmp/stream/sock. השדה הזה מציין שסוג הקופסה הוא UDS מבוססת זרם. השורה השנייה מראה שהסוג הוא u_dgr, מה שאומר שסוג הקופסה הוא מבוססת דתאגרמות.

מכיוון שקופסאות הדומיין Unix הן קבצים, אפשר להשתמש בהרשאות ובשליטה גישה רגילות של משתמש וקבוצה בלינוקס כדי להגביל מי יכול להתחבר לקופסה. ניתן גם להשתמש בכלי מערכת הקבצים כמו ls, mv, chown ו־chmod כדי לבדוק ולנהל קבצי UDS. כלים כמו SELinux גם יכולים לשמש לסמן קבצי UDS עם קשות מאבטח שונות.

כדי לבדוק אם קובץ הוא קופסת דומיין Unix, השתמש בכלי השרת ls, file או stat. עם זאת, חשוב לציין כי אף אחד מהם לא יכול לקבוע האם ה־UDS הוא מבוסס זרם או דתאגרמות. השתמש בכלי ה־ss למידע המלא ביותר על קופסת דומיין Unix.

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

stat /tmp/stream.sock /tmp/datagram.sock

תקבל פלט כמו הבא:

Output
  File: /tmp/stream.sock
  Size: 0             Blocks: 1          IO Block: 131072 socket
Device: 48h/72d    Inode: 1742        Links: 1
Access: (0755/srwxr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2021-03-01 18:10:25.025755168 +0000
Modify: 2021-03-01 18:10:25.025755168 +0000
Change: 2021-03-01 18:22:42.678231700 +0000
 Birth: -
  File: /tmp/datagram.sock
  Size: 0             Blocks: 1          IO Block: 131072 socket
Device: 48h/72d    Inode: 1743        Links: 1
Access: (0755/srwxr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2021-03-01 18:10:25.025755168 +0000
Modify: 2021-03-01 18:10:25.025755168 +0000
Change: 2021-03-01 18:10:25.025755168 +0000
 Birth: -

שים לב שעבור כל קובץ, הסוג הוא socket (מודגש בצד ימין של הפלט) ומצב הגישה מכיל אות s לפני ההיתרים של הקובץ.

הכלי ls גם יציין אם קובץ הוא סוקט. הפעל ls -l כדי לבדוק את הקבצים:

ls -l /tmp/stream.sock /tmp/datagram.sock

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

Output
srwxr-xr-x 1 root root 0 Mar  1 18:10 /tmp/datagram.sock
srwxr-xr-x 1 root root 0 Mar  1 18:10 /tmp/stream.sock

עכשיו שיצרת סוקטים של תחום Unix, ולמדת כיצד לבחון אותם באמצעות הכלים של ss ושונים על בסיס הקובץ, השלב הבא הוא לבדוק את הסוקטים באמצעות כלי כמו netcat.

בדיקת סוקטים של תחום Unix

הכלי netcat ניתן לשימוש כדי להתחבר לסוקטים של תחום Unix, וגם לסוקטים TCP ו-UDP שכבר למדת עליהם מוקדם יותר במדריך זה. כדי להתחבר לסוקטים הדוגמתיים שיצרת, יהיה עליך לציין דגל נוסף -U בעת הרצת פקודת ה-netcat. הדגל הזה מודיע ל-netcat להתחבר ל-UDS, להבדיל מסוקט רשת בסיסי של TCP או UDP.

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

בואו נתחיל בבדיקת קצוות קונקטורי תקשורת UDS על ידי התחברות לסוקט המבוסס על זרם עם הפקודה הבאה:

nc -U -z /tmp/stream.sock

האופציה -U מספרת ל־netcat שהוא מתחבר לסוקט של דומיין Unix. האופציה –z מבטיחה ש־netcat רק יתחבר לסוקט, בלי לשלוח נתונים. ה־/tmp/stream.sock הוא כתובת הסוקט במערכת הקבצים.

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

Output
nc: unix connect failed: No such file or directory
nc: /tmp/stream.sock: No such file or directory

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

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

nc -uU -z /tmp/datagram.sock

הדגל הנוסף -u מתווסף כדי לספר ל־netcat שהסוקט המרוחק הוא סוקט דטגרמי. שוב, לא תקבלו פלט אם הבדיקה מוצלחת.

אם אין סוקט בכתובת, תקבלו הודעת שגיאה דומה לזו:

Output
nc: unix connect failed: No such file or directory
nc: /tmp/datagram.sock: No such file or directory

כדי לנקות את הסוקטים שלכם, תצטרכו להריץ את הפקודה fg (foreground) עבור כל תהליך socat שיצרתם. לאחר מכן, תשתמשו ב־CTRL+C כדי לסגור את כל socat.

הריצו fg כדי להביא את המופע של socat המבוסס על דטגרמות לרקע של טרמינל האותיות שלכם:

fg

תקבלו פלט כמו בדוגמה הבאה:

Output
socat unix-recvfrom:/tmp/datagram.sock,fork /dev/null

הריצו CTRL+C כדי לסגור אותו. לא תקבלו פלט.

כעת הריצו שוב fg כדי לנקות את סוקט UDS המבוסס על זרם הראשון.

שוב תקבלו פלט דומה לדוגמה הבאה:

Output
socat unix-listen:/tmp/stream.sock,fork /dev/null

הרץ CTRL+C כדי לסיים את התהליך. לא תקבלו פלט.

עכשיו יצרת, בדקת ובחנת כניסות סוקטים של Unix Datagram במערכתך. נסה לנסות ולבצע ניסויים עם netcat ו-socat כדי להתעסק יותר עם איך ניתן לשלוח ולקבל נתונים על ידי כניסות אלו, וכיצד ניתן לבדוק ולפתור בעיות בכניסות דומיין Unix.

מסקנה

במדריך זה ביקרת בשימוש של כניסות שונות במערכת Linux. למדת על כניסות בעיקר מבוססות על זרם, אשר נוהגות להשתמש ב־TCP לתקשורת ברשת. למדת גם על כניסות בעיקר מבוססות על חבילות, שמשתמשות ב־UDP לשליחת נתונים ברשתות. לבסוף, בדקת כיצד ניתן להשתמש בכניסות דומיין Unix שיכולות להיות בעיקר מבוססות על זרם או על חבילות בשרת מקומי.

בכל סעיף השתמשת בכלי ה־ss כדי לאסוף מידע אודות כניסות במערכת Linux. למדת כיצד הדגלים השונים שמספק כלי ה־ss יכולים לסייע לך להגביל את הפלט שלו לסוגים ספציפיים של כניסות כאשר אתה בודק כניסות במערכת.

לבסוף, השתמשת בכלי ה־netcat וב־socat כדי ליצור ולהתחבר לכל אחד משלושת סוגי הקופסאות השונים שנדונו במדריך זה. תוכנת ה־netcat נפוצה מאוד להתחברות לקופסאות, אך היא יכולה גם ליצור קופסאות. התיעוד שלה (man nc) מכיל מספר דוגמאות רבות של כיצד ניתן להשתמש בה בשני המצבים. כלי ה־socat הוא כלי מתקדם יותר שניתן להשתמש בו כדי להתחבר וליצור קופסאות מסוגים שונים הלא מופיעים במדריך זה. התיעוד שלו (man socat) מכיל גם המון דוגמאות לדרכים שונות שבהן ניתן להשתמש בו.

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