Netzwerkports und Sitzungen mit netstat unter Linux analysieren

Einführung

In diesem Labor lernen Sie, wie Sie den Befehl netstat zur Analyse der Netzwerkaktivität auf einem Linux-System verwenden. Sie werden grundlegende Konzepte wie Netzwerkports, Sockets und aktive Verbindungen untersuchen, um Einblicke zu gewinnen, wie Dienste über das Netzwerk kommunizieren.

Sie beginnen damit, alle aktiven Sockets aufzulisten und filtern dann die Ergebnisse, um sich auf lauschende TCP- und UDP-Ports zu konzentrieren und diese ihren laufenden Diensten zuzuordnen. Um diese Konzepte in Aktion zu sehen, generieren Sie eine neue Verbindung, indem Sie eine Website durchsuchen, und verwenden dann netstat, um die neu erstellte ESTABLISHED-Sitzung und ihren zugehörigen temporären Port zu identifizieren.

Alle aktiven und lauschenden Sockets mit netstat -a auflisten

In diesem Schritt beginnen Sie mit der Untersuchung der Netzwerkaktivität Ihres Systems mithilfe des Befehls netstat. Dieser Befehl ist ein grundlegendes Werkzeug für Netzwerkadministratoren und Entwickler und liefert Einblicke in Netzwerkverbindungen, Routing-Tabellen und Schnittstellenstatistiken. Wir beginnen mit der Option -a, die netstat anweist, alle aktiven Sockets anzuzeigen, einschließlich Verbindungen zu entfernten Systemen und Ports, die auf neue eingehende Verbindungen "lauschen".

Stellen Sie zunächst sicher, dass Sie sich in Ihrem Standardarbeitsverzeichnis befinden. Alle Befehle in diesem Labor werden vom Terminal aus ausgeführt.

Listen wir nun alle Sockets auf. Geben Sie in Ihrem Terminal den folgenden Befehl ein und drücken Sie Enter:

netstat -a

Sie werden eine große Menge an Ausgabe sehen. Keine Sorge, wir werden sie aufschlüsseln. Die Ausgabe zeigt alle Arten von Sockets an, einschließlich TCP, UDP und UNIX-Domain-Sockets.

Untersuchen wir die Struktur der Ausgabe. Sie sollte in etwa so aussehen (die genauen Details auf Ihrem System können variieren):

Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 0.0.0.0:ssh             0.0.0.0:*               LISTEN
tcp        0      0 localhost:6010          0.0.0.0:*               LISTEN
tcp        0     52 labex-vm:ssh            192.168.0.10:54321      ESTABLISHED
tcp6       0      0 [::]:http-alt           [::]:*                  LISTEN
udp        0      0 0.0.0.0:bootpc          0.0.0.0:*
...
Active UNIX domain sockets (servers and established)
Proto RefCnt Flags       Type       State         I-Node   Path
unix  2      [ ]         DGRAM                    23456    /run/systemd/notify
unix  2      [ ACC ]     STREAM     LISTENING     34567    /tmp/.X11-unix/X0
...

Hier ist eine Aufschlüsselung der wichtigsten Spalten für Internetverbindungen:

• Proto: Das vom Socket verwendete Protokoll, z. B. tcp (für TCPv4), tcp6 (für TCPv6) oder udp.
• Local Address: Die IP-Adresse Ihres Systems und die Portnummer, die es für diese Verbindung verwendet. Der Port ist die Nummer nach dem Doppelpunkt (:). Eine Adresse von 0.0.0.0 oder [::] bedeutet, dass der Port auf allen verfügbaren Netzwerkschnittstellen Ihres Rechners lauscht.
• Foreign Address: Die IP-Adresse und Portnummer des entfernten Systems. Wenn der Status LISTEN ist, ist dies typischerweise 0.0.0.0:* oder [::]:*, was darauf hinweist, dass auf eine Verbindung von einer beliebigen Adresse gewartet wird.
• State: Dies ist entscheidend für TCP-Verbindungen.
  • LISTEN: Die Anwendung wartet auf eine eingehende Verbindung auf dem angegebenen Port der Local Address. Dies ist ein serverseitiger Status.
  • ESTABLISHED: Eine Verbindung ist aktiv und Daten können zwischen der lokalen und der entfernten Adresse übertragen werden.
  • Andere Status wie TIME_WAIT oder CLOSE_WAIT beziehen sich auf den Prozess des Schließens einer TCP-Verbindung.

Nehmen Sie sich einen Moment Zeit, um die Ausgabe durchzuscrollen und alle Einträge im Status LISTEN zu identifizieren. Diese repräsentieren Dienste auf Ihrem System, die bereit sind, Netzwerkverbindungen anzunehmen. Dies ist ein direkter Einblick in die Transportschicht (Schicht 4) in Aktion.

Nach lauschenden TCP/UDP-Ports filtern mit sudo netstat -tulnp

Im vorherigen Schritt lieferte uns der Befehl netstat -a eine vollständige, aber lange Liste aller Sockets. Um diese Informationen nützlicher zu machen, müssen wir sie filtern. In diesem Schritt lernen Sie, wie Sie mit spezifischen Optionen netstat verwenden, um nur die lauschenden TCP- und UDP-Ports anzuzeigen und, was am wichtigsten ist, zu identifizieren, welche Programme sie verwenden.

Um den Programmnamen, der einem Port zugeordnet ist, anzuzeigen, benötigen Sie oft Administratorrechte, da der Prozess dem System oder einem anderen Benutzer gehören könnte. Deshalb verwenden wir den Befehl sudo. In der LabEx-Umgebung können Sie sudo ohne Passwort verwenden.

Führen wir einen fokussierteren netstat-Befehl aus. Geben Sie in Ihrem Terminal Folgendes ein:

sudo netstat -tulnp

Lassen Sie uns diese Optionen aufschlüsseln, da sie häufig kombiniert werden:

• t: Zeigt TCP-Verbindungen an.
• u: Zeigt UDP-Verbindungen an.
• l: Zeigt nur lauschende Sockets an. Dies ist unser primärer Filter, um zu sehen, welche Dienste auf Verbindungen warten.
• n: Zeigt numerische Adressen an. Dies verhindert, dass netstat versucht, IP-Adressen und Portnummern in Hostnamen und Servicenamen aufzulösen (z. B. zeigt es 22 anstelle von ssh), was den Befehl viel schneller ausführt.
• p: Zeigt die Prozess-ID (PID) und den Namen des Programms an, zu dem der Socket gehört. Dies erfordert sudo, um alle Prozesse anzuzeigen.

Nachdem Sie Enter gedrückt haben, wird Ihre Ausgabe viel kürzer und informativer sein. Sie wird in etwa so aussehen:

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      779/systemd-resolve
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      3422/sshd
udp        0      0 127.0.0.53:53           0.0.0.0:*                           779/systemd-resolve

Beachten Sie die neue Spalte am Ende: PID/Program name. Dies ist die wichtigste Information. Sie können nun einen lauschenden Port direkt der genauen Anwendung zuordnen, die ihn geöffnet hat. Im obigen Beispiel sehen Sie beispielsweise, dass Port 22 (der Standardport für SSH) vom Programm sshd mit einer Prozess-ID von 3422 verwendet wird.

Dieser Befehl ist für Systemadministratoren äußerst nützlich. Er ermöglicht es Ihnen, schnell zu überprüfen, welche Dienste ausgeführt werden und im Netzwerk verfügbar sind, was sowohl für die Fehlerbehebung als auch für die Sicherheitsüberprüfung unerlässlich ist.

Lauschende Ports laufenden Diensten zuordnen

In diesem Schritt festigen Sie Ihr Verständnis der Verbindung zwischen laufenden Anwendungen und lauschenden Netzwerkports. Sie haben gesehen, wie Sie bestehende Dienste mit netstat auflisten können. Nun starten Sie Ihren eigenen einfachen Webdienst und beobachten, wie er in der netstat-Ausgabe erscheint, um diese Beziehung in Echtzeit zu demonstrieren.

Wir verwenden das integrierte http.server-Modul von Python, um schnell einen Webserver zu starten. Dies ist ein praktisches Werkzeug für Entwicklung und Tests.

1. Starten wir zuerst den Webserver. Wir weisen ihn an, auf Port 8080 zu lauschen, einem gängigen alternativen Port für Webdienste. Führen Sie in Ihrem Terminal den folgenden Befehl aus. Beachten Sie, dass Ihr Terminal "hängen" zu bleiben scheint, da es nun aktiv den Server ausführt.

   python3 -m http.server 8080
   

   Sie sollten eine Ausgabe sehen, die anzeigt, dass der Server gestartet wurde:

   Serving HTTP on 0.0.0.0 port 8080 (http://0.0.0.0:8080/) ...
   

2. Dieses Terminal ist nun vom Webserver-Prozess belegt. Sie benötigen ein neues Terminal, um andere Befehle auszuführen. In der LabEx-Umgebung können Sie einen neuen Terminal-Tab öffnen, indem Sie auf das "Plus"-Symbol im Terminalfenster klicken oder das Menü (Datei -> Neuer Tab) verwenden.

3. Führen Sie in Ihrem neuen Terminal-Tab erneut den netstat-Befehl aus, um die Liste der lauschenden Ports anzuzeigen.

   sudo netstat -tulnp
   

4. Untersuchen Sie die Ausgabe sorgfältig. Sie werden nun einen neuen Eintrag für Port 8080 sehen.

   Active Internet connections (only servers)
   Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
   tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      779/systemd-resolve
   tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      3422/sshd
   tcp        0      0 0.0.0.0:8080            0.0.0.0:*               LISTEN      12345/python3
   udp        0      0 127.0.0.53:53           0.0.0.0:*                           779/systemd-resolve
   ...
   

   Wie Sie sehen können, meldet das System nun, dass das Programm python3 (mit einer spezifischen PID, z. B. 12345) im Status LISTEN auf Port 8080 ist. Sie haben erfolgreich einen Dienst gestartet und bestätigt, dass er auf Netzwerkverbindungen wartet.

5. Stoppen wir nun den Dienst. Kehren Sie zu Ihrem ersten Terminal-Tab (dem, der den Python-Server ausführt) zurück und drücken Sie Ctrl+C. Dies unterbricht und beendet den Server-Prozess.

6. Kehren Sie zum zweiten Terminal-Tab zurück und führen Sie den netstat-Befehl ein letztes Mal aus.

   sudo netstat -tulnp
   

   Die Zeile für Port 8080 wird verschwunden sein, was beweist, dass eine Anwendung, wenn sie beendet wird, nicht mehr auf dem Port lauscht.

Neue Verbindung durch Browsen einer Website erstellen

In diesem Schritt verlagern Sie Ihren Fokus von lauschenden Server-Ports auf aktive Client-Verbindungen. Bisher haben Sie Dienste beobachtet, die darauf warten, dass andere sich mit ihnen verbinden. Nun initiieren Sie eine Verbindung von Ihrem Rechner zu einem entfernten Server und beobachten, wie die Verbindung aufgebaut wird. Wir verwenden das Kommandozeilenwerkzeug curl, um den Besuch einer Website zu simulieren.

Um dieses flüchtige Ereignis zu beobachten, verwenden wir den Befehl watch, der einen anderen Befehl wiederholt ausführt und es uns ermöglicht, Änderungen in der Ausgabe von netstat nahezu in Echtzeit zu sehen.

1. Richten wir zunächst unser Überwachungsfenster ein. Führen Sie in Ihrem Terminal den folgenden Befehl aus. Dieser wird netstat -antp alle zwei Sekunden ausführen und die Ergebnisse anzeigen, wobei der Bildschirm kontinuierlich aktualisiert wird.

   watch netstat -antp
   

   • a: Zeigt alle Sockets an.
   • n: Zeigt numerische Adressen an.
   • t: Zeigt nur TCP-Verbindungen an.
   • p: Zeigt die PID/den Programmnamen an.

   Ihr Terminal wird nun mit der netstat-Ausgabe gefüllt, die sich automatisch aktualisiert. Lassen Sie dieses Terminal geöffnet und sichtbar.

2. Nun müssen Sie einen neuen Terminal-Tab öffnen, um den Befehl auszuführen, der die Verbindung herstellt. Klicken Sie auf das "Plus"-Symbol in der Tab-Leiste Ihres Terminals.

3. Im neuen Terminal-Tab verwenden Sie curl, um die Homepage der LabEx-Website abzurufen. Das Symbol > leitet die HTML-Ausgabe nach /dev/null um, damit sie Ihren Bildschirm nicht überfüllt.

   curl https://www.labex.io > /dev/null
   

4. Sobald Sie Enter drücken, wechseln Sie schnell zurück zu Ihrem ersten Terminal-Tab (dem, der watch ausführt). Sie werden sehen, wie für einige Sekunden eine neue Verbindung erscheint. Sie wird ungefähr so aussehen:

   Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
   ...
   tcp        0      0 172.17.0.2:45678        104.21.5.141:443        ESTABLISHED 13579/curl
   ...
   

   • Beachten Sie, dass der State ESTABLISHED ist, was auf eine aktive Verbindung hinweist.
   • Die Foreign Address zeigt die IP-Adresse des labex.io-Servers und den Port 443 (der Standard für HTTPS) an.
   • Die Spalte PID/Program name identifiziert klar curl als das Programm, das diese Verbindung initiiert hat.
   • Die Local Address verwendet einen zufälligen Port mit hoher Nummer (wie 45678 im Beispiel). Dies ist ein ephemerer Port, den wir im nächsten Schritt besprechen werden.

5. Sobald der curl-Befehl den Download abgeschlossen hat (was sehr schnell geht), sehen Sie, wie sich der Verbindungsstatus zu TIME_WAIT oder FIN_WAIT ändert, bevor er vollständig aus der Liste verschwindet.

6. Sie können nun den watch-Befehl stoppen. Gehen Sie zum ersten Terminal-Tab und drücken Sie Ctrl+C. Sie können auch den zweiten Terminal-Tab schließen.

ESTABLISHED-Sitzung und temporäre Ports identifizieren

In diesem letzten Schritt festigen Sie Ihr Verständnis, indem Sie eine persistente, aktive Verbindung untersuchen. Dies ermöglicht es Ihnen, eine Netzwerk-"Sitzung" klar zu identifizieren und zu sehen, wie Ihr System temporäre oder "ephemere" Ports für die clientseitige Kommunikation verwendet.

Eine ESTABLISHED-Verbindung in der Ausgabe von netstat repräsentiert eine aktive Sitzung (OSI-Schicht 5), bei der zwei Anwendungen bereit sind, Daten auszutauschen. In der vorherigen Schritt war die curl-Sitzung sehr kurzlebig. Um eine Sitzung einfacher zu untersuchen, erstellen wir eine, die offen bleibt, indem wir SSH verwenden.

Zuerst definieren wir ein wichtiges Konzept: ephemere Ports. Wenn Ihr Computer (der Client) eine Verbindung zu einem Server über einen bekannten Port (wie Port 22 für SSH oder 443 für HTTPS) herstellt, muss Ihr Betriebssystem einen Port für seine Seite der Konversation zuweisen. Es wählt einen temporären, ungenutzten Port aus einem Bereich mit hoher Nummerierung (typischerweise über 32768). Dies wird als ephemerer Port bezeichnet. Dieser Mechanismus ermöglicht es Ihrem einzelnen Rechner, viele separate Verbindungen zum selben Server-Port zu haben, zum Beispiel, wenn mehrere Browser-Tabs zur selben Website geöffnet sind.

1. Um eine stabile, beobachtbare Sitzung zu erstellen, verbinden Sie sich per SSH von Ihrem Laborrechner zurück zu sich selbst. Führen Sie in Ihrem Terminal den folgenden Befehl aus:

   ssh localhost
   

   Wenn Sie dies zum ersten Mal tun, sehen Sie möglicherweise eine Meldung über die Authentizität des Hosts. Das ist normal.

   The authenticity of host 'localhost (127.0.0.1)' can't be established.
   ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
   Are you sure you want to continue connecting (yes/no/[fingerprint])?
   

   Geben Sie yes ein und drücken Sie Enter, um fortzufahren.

   Es wird Sie zur Eingabe des Passworts auffordern. Sie müssen das Passwort nicht eingeben, bleiben Sie einfach dort.

2. Öffnen Sie einen neuen Terminal-Tab, indem Sie auf das "Plus"-Symbol klicken. Wir benötigen dieses neue Terminal, um netstat auszuführen, ohne unsere aktive SSH-Sitzung zu stören.

3. Führen Sie im neuen Terminal erneut netstat aus, aber diesmal verwenden wir den Befehl grep, um die Ausgabe zu filtern und nur die Zeilen anzuzeigen, die ESTABLISHED enthalten. Dies erleichtert das Finden aktiver Sitzungen erheblich.

   netstat -antp | grep ESTABLISHED
   

4. Die Ausgabe zeigt alle aktuell aktiven TCP-Verbindungen an. Möglicherweise sehen Sie eine Warnung, dass nicht alle Prozesse identifiziert werden konnten, was erwartet wird, da wir sudo nicht verwenden. Sie sollten Ihre ursprüngliche SSH-Verbindung zur Lab-Umgebung und die neue, die Sie gerade zu localhost erstellt haben, sehen.

   (Not all processes could be identified, non-owned process info
    will not be shown, you would have to be root to see it all.)
   tcp        0      0 172.16.50.192:22        47.251.66.143:36882     ESTABLISHED -
   tcp        0      0 127.0.0.1:46280         127.0.0.1:22            ESTABLISHED 5449/ssh
   tcp        0      0 127.0.0.1:22            127.0.0.1:46280         ESTABLISHED -
   

   Analysieren wir die neue localhost-Verbindung, die durch die Adresse 127.0.0.1 identifiziert wird:

   • Die Serverseite der Verbindung ist 127.0.0.1:22, das ist der SSH-Server (sshd), der auf Port 22 lauscht. Er hat eine bestehende Verbindung von 127.0.0.1:46280. Die Programminformation ist -, da der sshd-Prozess dem Benutzer root gehört und wir sudo nicht verwendet haben.
   • Die Clientseite ist 127.0.0.1:46280, verbunden mit 127.0.0.1:22. Das Programm ist klar als 5449/ssh identifiziert.
   • Der Port 46280 ist der ephemere Port. Ihr System hat ihn zufällig für das Client-Ende dieser spezifischen SSH-Sitzung gewählt. Wenn Sie eine weitere ssh localhost-Verbindung öffnen würden, würde diese einen anderen ephemeren Port verwenden.

5. Um zu beenden, schließen Sie die Sitzung. Wechseln Sie zurück zum Terminal-Tab, in dem Sie ssh localhost ausgeführt haben, und geben Sie exit ein, gefolgt von Enter.

   exit
   

   Dies beendet die Verbindung. Wenn Sie in dem anderen Terminal erneut netstat -antp | grep ESTABLISHED ausführen, werden Sie sehen, dass die localhost-Sitzung verschwunden ist.

Zusammenfassung

In diesem Labor haben Sie gelernt, wie Sie den Befehl netstat zur Analyse der Netzwerkaktivität auf einem Linux-System verwenden. Sie haben zunächst netstat -a verwendet, um alle aktiven und lauschenden Sockets aufzulisten, einschließlich TCP-, UDP- und UNIX-Domain-Sockets. Anschließend haben Sie diese Ausgabe verfeinert, indem Sie Flags wie -t, -u, -l, -n und -p angewendet haben, um gezielt nach lauschenden TCP- und UDP-Ports zu filtern, numerische Adressen anzuzeigen und die Prozess-ID und den Namen zu identifizieren, die jedem Port zugeordnet sind.

Darauf aufbauend haben Sie die Ausgabe des Befehls interpretiert, um lauschende Ports ihren entsprechenden Diensten zuzuordnen. Um eine Verbindung in Aktion zu beobachten, haben Sie eine neue Netzwerksitzung initiiert, indem Sie eine Verbindung zu einer Website hergestellt haben. Dies ermöglichte es Ihnen, eine Verbindung im Zustand ESTABLISHED zu identifizieren und die Rolle von ephemeren Ports zu verstehen, bei denen es sich um temporäre Ports handelt, die der Client-Seite einer Netzwerkkommunikation zugewiesen werden.