Wie man Curl zum Zugriff auf verschiedene Ports verwendet

LinuxBeginner
Jetzt üben

Einführung

Curl ist ein leistungsstarkes Kommandozeilen-Tool, mit dem Sie Daten mithilfe verschiedener Protokolle wie HTTP, FTP und SFTP übertragen können. In diesem Tutorial erfahren Sie, wie Sie Curl verwenden, um auf verschiedene Ports auf Ihrem Server oder Netzwerk zuzugreifen. Dies ermöglicht Ihnen, Konnektivitätsprobleme zu beheben und die Portverfügbarkeit zu testen.

Dieses praktische Lab führt Sie durch grundlegende und erweiterte Curl-Befehle für den Portzugriff und hilft Ihnen zu verstehen, wie Netzwerkdienste auf verschiedenen Ports arbeiten. Am Ende dieses Labs werden Sie in der Lage sein, Curl sicher zu verwenden, um mit Diensten zu interagieren, die auf verschiedenen Ports laufen.

Erste Schritte mit Curl

Curl, was für "Client URL" steht, ist ein Kommandozeilen-Tool zum Übertragen von Daten zu oder von einem Server. Es unterstützt zahlreiche Protokolle, darunter HTTP, HTTPS, FTP, SFTP und viele mehr. Bevor wir uns mit portspezifischen Operationen befassen, stellen wir sicher, dass Sie die grundlegende Verwendung von Curl verstehen.

Grundlegender Curl-Befehl

Öffnen Sie Ihr Terminal und geben Sie den folgenden Befehl ein, um zu überprüfen, ob Curl auf Ihrem System installiert ist:

curl --version

Sie sollten eine ähnliche Ausgabe wie diese sehen, die die Curl-Version und die unterstützten Funktionen anzeigt:

curl 7.81.0 (x86_64-pc-linux-gnu) libcurl/7.81.0 OpenSSL/3.0.2 zlib/1.2.11 brotli/1.0.9 zstd/1.4.8 libidn2/2.3.2 libpsl/0.21.0 (+libidn2/2.3.2) libssh/0.9.6/openssl/zlib nghttp2/1.43.0 librtmp/2.3 OpenLDAP/2.5.13
Release-Date: 2022-01-05
Protocols: dict file ftp ftps gopher gophers http https imap imaps ldap ldaps mqtt pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp
Features: alt-svc AsynchDNS brotli GSS-API HSTS HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM NTLM_WB PSL SPNEGO SSL TLS-SRP UnixSockets zstd

Versuchen wir nun eine einfache Curl-Anfrage an eine Website. Geben Sie den folgenden Befehl ein:

curl https://example.com

Dieser Befehl lädt den HTML-Inhalt von example.com herunter und zeigt ihn in Ihrem Terminal an. Die Ausgabe sieht in etwa so aus:

<!doctype html>
<html>
  <head>
    <title>Example Domain</title>
    <!-- More HTML content -->
  </head>
  <body>
    <div>
      <h1>Example Domain</h1>
      <p>This domain is for use in illustrative examples in documents...</p>
      <!-- More HTML content -->
    </div>
  </body>
</html>

HTTP-Ports verstehen

Webserver laufen typischerweise auf bestimmten Ports:

  • Port 80 für HTTP (ungesichert)
  • Port 443 für HTTPS (gesichert)

Wenn Sie auf eine Website zugreifen, ohne einen Port anzugeben, verwendet Ihr Browser automatisch diese Standardports. Mit Curl können Sie jedoch explizit angeben, mit welchem Port Sie sich verbinden möchten.

Versuchen wir, auf eine Website über den Standard-HTTP-Port (Port 80) zuzugreifen:

curl http://example.com:80

Die Ausgabe sollte der vorherigen Curl-Anfrage ähneln, da Port 80 der Standard für HTTP ist.

Versuchen Sie nun, auf dieselbe Website über den HTTPS-Port (Port 443) zuzugreifen:

curl https://example.com:443

Auch hier sollte die Ausgabe ähnlich sein, da Port 443 der Standard für HTTPS ist.

In diesen Beispielen haben wir die Ports explizit in der URL mit dem Format protocol://domain:port angegeben. Diese Syntax ist entscheidend, wenn Sie mit Diensten auf nicht standardmäßigen Ports arbeiten.

Verwendung von Curl mit verschiedenen Ports

Nachdem Sie die Grundlagen von Curl und die Ports-Spezifikation verstanden haben, wollen wir untersuchen, wie man mit verschiedenen Ports interagiert.

Zugriff auf nicht standardmäßige Web-Ports

Webserver können auf anderen Ports als 80 und 443 laufen. Für Testzwecke richten wir einen einfachen Webserver auf Port 8000 mit dem integrierten HTTP-Server von Python ein.

Erstellen Sie zuerst eine einfache HTML-Datei, die bereitgestellt werden soll:

echo "<html><body><h1>Hello from port 8000!</h1></body></html>" > ~/project/test.html

Navigieren Sie nun zu dem Verzeichnis, das die Datei enthält, und starten Sie einen einfachen HTTP-Server auf Port 8000:

cd ~/project
python3 -m http.server 8000 &

Das & am Ende des Befehls führt den Server im Hintergrund aus. Sie sollten eine Ausgabe wie diese sehen:

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

Verwenden Sie nun Curl, um auf diesen Server auf Port 8000 zuzugreifen:

curl http://localhost:8000/test.html

Sie sollten den von uns erstellten HTML-Inhalt sehen:

<html>
  <body>
    <h1>Hello from port 8000!</h1>
  </body>
</html>

Wenn wir mit dem Server fertig sind, können wir ihn stoppen, indem wir seine Prozess-ID ermitteln und ihn beenden:

ps aux | grep "python3 -m http.server"

Dies zeigt eine Ausgabe ähnlich der folgenden:

labex     1234  0.0  0.1 235368 12312 pts/0    S    10:00   0:00 python3 -m http.server 8000
labex     1235  0.0  0.0  12345  1234 pts/0    S+   10:01   0:00 grep --color=auto python3 -m http.server

Beachten Sie die Prozess-ID (PID) in der zweiten Spalte (1234 in diesem Beispiel) und beenden Sie den Prozess:

kill $(pgrep -f "python3 -m http.server")

Verwendung verschiedener HTTP-Methoden

Curl ermöglicht es Ihnen, verschiedene HTTP-Methoden mit dem Flag -X anzugeben. Versuchen wir eine POST-Anfrage:

curl -X POST http://example.com

Dies sendet eine POST-Anfrage an example.com. Die meisten Websites antworten mit einer Meldung, die darauf hinweist, dass sie andere Daten für POST-Anfragen erwarten.

Hinzufügen von Headern zu Anfragen

Bei der Arbeit mit APIs oder bestimmten Diensten müssen Sie häufig benutzerdefinierte Header senden. Dies können Sie mit dem Flag -H tun:

curl -H "Content-Type: application/json" http://example.com

Dies sendet eine Anfrage mit einem JSON-Content-Type-Header. Die Antwort hängt davon ab, wie der Server diesen Header verarbeitet.

Anzeigen von Antwort-Headern

Um die Antwort-Header zusammen mit dem Inhalt anzuzeigen, verwenden Sie das Flag -i:

curl -i http://example.com

Dies zeigt eine Ausgabe ähnlich der folgenden:

HTTP/1.1 200 OK
Content-Encoding: gzip
Accept-Ranges: bytes
Age: 558039
Cache-Control: max-age=604800
Content-Type: text/html; charset=UTF-8
Date: Wed, 07 Jun 2023 12:34:56 GMT
Etag: "3147526947+gzip"
Expires: Wed, 14 Jun 2023 12:34:56 GMT
Last-Modified: Thu, 17 Oct 2019 07:18:26 GMT
Server: ECS (dcb/7F5B)
Vary: Accept-Encoding
X-Cache: HIT
Content-Length: 1256

<!doctype html>
<html>
<head>
    <title>Example Domain</title>
    <!-- More HTML content -->
</head>
<!-- More HTML content -->
</html>

Die Header liefern wertvolle Informationen über den Server, den Inhaltstyp, die Caching-Richtlinien und mehr.

Erweiterte Port-Zugriffe mit Curl

Nachdem Sie die Grundlagen der Verwendung von Curl mit verschiedenen Ports verstanden haben, wollen wir uns mit fortgeschritteneren Techniken für den Port-Zugriff und das Testen befassen.

Testen der Port-Verfügbarkeit

Curl kann verwendet werden, um zu überprüfen, ob ein bestimmter Port auf einem Server geöffnet ist. Wenn ein Port geöffnet ist, versucht Curl, eine Verbindung herzustellen und möglicherweise Daten zu empfangen. Wenn ein Port geschlossen ist, meldet Curl einen Fehler.

Testen wir einige gängige Ports:

## Test if port 80 (HTTP) is open
curl -s -o /dev/null -w "%{http_code}\n" http://example.com:80

Dieser Befehl zeigt den HTTP-Statuscode an (typischerweise 200, wenn der Port geöffnet ist und der Server korrekt antwortet). Das Flag -s macht Curl still, -o /dev/null leitet die Ausgabe nirgendwohin um, und -w "%{http_code}\n" gibt nur den HTTP-Statuscode aus.

Versuchen wir noch ein paar Ports:

## Test if port 443 (HTTPS) is open
curl -s -o /dev/null -w "%{http_code}\n" https://example.com:443

Dies sollte 200 oder einen anderen HTTP-Statuscode zurückgeben, was darauf hindeutet, dass Port 443 geöffnet ist.

Testen wir nun einen Port, der wahrscheinlich geschlossen ist:

## Test if port 81 (uncommon) is open
curl -s --connect-timeout 5 http://example.com:81

Dieser Befehl schlägt wahrscheinlich mit einer Fehlermeldung wie dieser fehl:

curl: (7) Failed to connect to example.com port 81: Connection refused

oder es könnte nach 5 Sekunden ein Timeout erfolgen (wie durch --connect-timeout angegeben):

curl: (28) Connection timed out after 5001 milliseconds

Zugriff auf FTP-Server

Curl unterstützt mehrere Protokolle, einschließlich FTP. Sehen wir uns an, wie man auf einen FTP-Server zugreift:

curl ftp://ftp.gnu.org/gnu/

Dieser Befehl listet den Inhalt des Verzeichnisses unter ftp.gnu.org auf. Die Ausgabe könnte so aussehen:

drwxr-xr-x    8 1003     1003         4096 Dec 16  2020 0ad
drwxr-sr-x    5 1003     1003         4096 Nov 09  2020 8sync
drwxr-xr-x    2 1003     1003         4096 Jun 05  2015 GNUinfo
drwxr-xr-x    3 1003     1003         4096 Jan 23  2022 GNUnet
...

Erstellen eines einfachen Port-Scanners

Erstellen wir ein einfaches Bash-Skript, um einen Bereich von Ports auf einem Server zu scannen. Erstellen Sie eine neue Datei namens port_scanner.sh in Ihrem Projektverzeichnis:

nano ~/project/port_scanner.sh

Fügen Sie den folgenden Inhalt in die Datei ein:

#!/bin/bash

## Simple port scanner using curl
## Usage: ./port_scanner.sh <hostname> <start_port> <end_port>

hostname=$1
start_port=$2
end_port=$3

echo "Scanning ports $start_port to $end_port on $hostname..."
echo

for port in $(seq $start_port $end_port); do
  ## Try to connect with a short timeout
  curl -s --connect-timeout 1 "$hostname:$port" > /dev/null

  ## Check if the connection was successful
  if [ $? -eq 0 ]; then
    echo "Port $port is OPEN"
  else
    echo "Port $port is closed"
  fi
done

echo
echo "Scan complete!"

Speichern Sie die Datei, indem Sie Ctrl+X, dann Y und dann Enter drücken.

Machen Sie das Skript ausführbar:

chmod +x ~/project/port_scanner.sh

Führen Sie nun das Skript aus, um die Ports 80-85 auf example.com zu scannen:

~/project/port_scanner.sh example.com 80 85

Die Ausgabe zeigt, welche Ports geöffnet und welche geschlossen sind:

Scanning ports 80 to 85 on example.com...

Port 80 is OPEN
Port 81 is closed
Port 82 is closed
Port 83 is closed
Port 84 is closed
Port 85 is closed

Scan complete!

Dieses einfache Skript demonstriert, wie Curl als grundlegendes Port-Scanning-Tool verwendet werden kann. In einem realen Szenario würden Sie spezialisierte Tools wie nmap für umfassenderes Netzwerk-Scanning verwenden wollen, aber dieses Beispiel zeigt die Vielseitigkeit von Curl.

Arbeiten mit HTTPS und sicheren Verbindungen

In diesem Schritt werden wir untersuchen, wie man Curl mit HTTPS verwendet und verschiedene sicherheitsrelevante Optionen handhabt.

Verstehen von HTTPS-Verbindungen

HTTPS-Verbindungen verwenden SSL/TLS-Protokolle, um die Datenübertragung zu sichern. Wenn Sie Curl verwenden, um sich mit einer HTTPS-Site zu verbinden, wird standardmäßig das SSL-Zertifikat des Servers überprüft.

Versuchen wir, uns mit einer sicheren Website zu verbinden:

curl https://www.google.com

Dieser Befehl stellt eine Verbindung zum HTTPS-Server von Google her und gibt den HTML-Inhalt zurück.

Umgang mit der SSL-Zertifikatsüberprüfung

Manchmal müssen Sie sich möglicherweise mit einem Server mit einem selbstsignierten oder ungültigen Zertifikat verbinden. In solchen Fällen können Sie die Option -k oder --insecure verwenden, um die Zertifikatsvalidierung zu überspringen:

curl -k https://www.google.com

Dieser Befehl stellt eine Verbindung zur Site her, auch wenn das Zertifikat nicht validiert werden kann. Die Ausgabe sollte der des vorherigen Befehls ähneln.

Anzeigen von Zertifikatsinformationen

Um das SSL-Zertifikat einer Website zu untersuchen, verwenden Sie die Option -v (verbose):

curl -v https://www.google.com > /dev/null

Dieser Befehl zeigt detaillierte Informationen über den SSL-Handshake und das Zertifikat an, während der eigentliche Inhalt an /dev/null gesendet wird. Die Ausgabe enthält Zertifikatsdetails:

* Server certificate:
*  subject: CN=www.google.com
*  start date: ...
*  expire date: ...
*  subjectAltName: ...
*  issuer: CN=GTS CA 1C3; O=Google Trust Services LLC; C=US
*  SSL certificate verify ok.

Verwenden bestimmter TLS-Versionen

Sie können mit der Option --tlsv1.X angeben, welche TLS-Version verwendet werden soll:

## Force TLS 1.2
curl --tlsv1.2 https://www.google.com > /dev/null

Dies stellt sicher, dass Curl TLS 1.2 für die Verbindung verwendet.

Sicheres Herunterladen von Dateien

Curl kann Dateien von HTTPS-Quellen herunterladen. Laden wir eine Datei herunter und speichern sie mit der Option -o:

curl -o ~/project/google_logo.png https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png

Dieser Befehl lädt das Logo von Google herunter und speichert es als google_logo.png in Ihrem Projektverzeichnis. Überprüfen Sie, ob die Datei existiert:

ls -l ~/project/google_logo.png

Sie sollten eine Ausgabe wie diese sehen:

-rw-r--r-- 1 labex labex 5969 Jun 7 12:34 /home/labex/project/google_logo.png

Angeben benutzerdefinierter Header für HTTPS

Bei der Arbeit mit sicheren APIs müssen Sie häufig Authentifizierungs-Header einfügen. So geht das:

curl -H "Authorization: Bearer your_token_here" https://api.example.com

Ersetzen Sie your_token_here durch ein tatsächliches Token, falls Sie eines haben. Andernfalls gibt dieser Befehl wahrscheinlich einen Fehler oder eine nicht autorisierte Meldung vom Server zurück.

Zugriff auf HTTPS auf nicht standardmäßigen Ports

HTTPS-Dienste können auf anderen Ports als 443 ausgeführt werden. Um auf solche Dienste zuzugreifen, geben Sie den Port in der URL an:

curl https://example.com:8443

Dieser Befehl versucht, sich mit einem HTTPS-Dienst auf Port 8443 zu verbinden. Da example.com keinen Dienst auf diesem Port hat, sehen Sie wahrscheinlich einen Fehler:

curl: (7) Failed to connect to example.com port 8443: Connection refused

Dies zeigt, dass Curl versuchen kann, sich mit jedem Port unter Verwendung jedes Protokolls zu verbinden, was es zu einem vielseitigen Werkzeug für das Testen von Netzwerkdiensten macht.

Erstellen eines umfassenden Port-Checking-Skripts

In diesem letzten Schritt erstellen wir ein ausgefeilteres Skript, das Curl verwendet, um gängige Dienste auf einem Zielserver zu überprüfen.

Verstehen gängiger Dienst-Ports

Verschiedene Dienste werden typischerweise auf Standard-Ports ausgeführt:

  • Web (HTTP): Port 80
  • Sicheres Web (HTTPS): Port 443
  • FTP: Port 21
  • SSH: Port 22
  • SMTP (E-Mail): Port 25
  • DNS: Port 53
  • Datenbank (MySQL): Port 3306
  • Datenbank (PostgreSQL): Port 5432

Erstellen wir ein Skript, das diese gängigen Ports auf einem bestimmten Host überprüft.

Erstellen des Service-Checker-Skripts

Erstellen Sie eine neue Datei namens service_checker.sh in Ihrem Projektverzeichnis:

nano ~/project/service_checker.sh

Fügen Sie den folgenden Inhalt in die Datei ein:

#!/bin/bash

## Service checker script using curl
## Usage: ./service_checker.sh <hostname>

hostname=$1

if [ -z "$hostname" ]; then
  echo "Error: Please provide a hostname."
  echo "Usage: ./service_checker.sh <hostname>"
  exit 1
fi

echo "Checking common services on $hostname..."
echo

## Function to check a port with appropriate protocol
check_port() {
  local port=$1
  local service=$2
  local protocol=$3
  local timeout=2

  echo -n "Checking $service (Port $port): "

  ## Use the appropriate protocol based on the service
  if [ "$protocol" = "http" ]; then
    curl -s --connect-timeout $timeout "http://$hostname:$port" > /dev/null
  elif [ "$protocol" = "https" ]; then
    curl -s --connect-timeout $timeout "https://$hostname:$port" > /dev/null
  else
    ## For non-HTTP protocols, just try to connect to the port
    curl -s --connect-timeout $timeout "$hostname:$port" > /dev/null
  fi

  ## Check the result
  if [ $? -eq 0 ]; then
    echo "AVAILABLE"
  else
    echo "Not available"
  fi
}

## Check common services
check_port 80 "Web Server (HTTP)" "http"
check_port 443 "Web Server (HTTPS)" "https"
check_port 21 "FTP Server" "tcp"
check_port 22 "SSH Server" "tcp"
check_port 25 "SMTP Server" "tcp"
check_port 53 "DNS Server" "tcp"
check_port 3306 "MySQL Database" "tcp"
check_port 5432 "PostgreSQL Database" "tcp"
check_port 8080 "Alternative Web Server" "http"
check_port 8443 "Alternative Secure Web Server" "https"

echo
echo "Service check complete!"

Speichern Sie die Datei, indem Sie Ctrl+X, dann Y und dann Enter drücken.

Machen Sie das Skript ausführbar:

chmod +x ~/project/service_checker.sh

Ausführen des Service-Checkers

Führen Sie nun das Skript aus, um Dienste auf einer bekannten Website zu überprüfen:

~/project/service_checker.sh example.com

Sie sehen eine Ausgabe ähnlich dieser:

Checking common services on example.com...

Checking Web Server (HTTP) (Port 80): AVAILABLE
Checking Web Server (HTTPS) (Port 443): AVAILABLE
Checking FTP Server (Port 21): Not available
Checking SSH Server (Port 22): Not available
Checking SMTP Server (Port 25): Not available
Checking DNS Server (Port 53): Not available
Checking MySQL Database (Port 3306): Not available
Checking PostgreSQL Database (Port 5432): Not available
Checking Alternative Web Server (Port 8080): Not available
Checking Alternative Secure Web Server (Port 8443): Not available

Service check complete!

Diese Ausgabe zeigt, dass example.com Webserver auf den Ports 80 und 443 ausführt, aber andere gängige Dienste nicht öffentlich zugänglich sind.

Verstehen der Ergebnisse

Die Ergebnisse unseres Skripts liefern wertvolle Informationen:

  1. Verfügbare Dienste: Diese Ports sind geöffnet und antworten auf Anfragen, was darauf hindeutet, dass die entsprechenden Dienste ausgeführt werden und zugänglich sind.

  2. Nicht verfügbare Dienste: Diese Ports könnten:

    • Geschlossen sein (kein Dienst läuft)
    • Durch eine Firewall gefiltert werden
    • Laufen, aber nicht konfiguriert sein, um auf allgemeine Anfragen zu antworten

Diese Informationen sind nützlich für:

  • Netzwerkadministratoren, die die Dienstverfügbarkeit überprüfen
  • Sicherheitsexperten, die eine erste Aufklärung durchführen
  • Entwickler, die überprüfen, ob ihre Dienste ordnungsgemäß konfiguriert sind

Modifizieren des Skripts

Sie können das Skript gerne ändern, um zusätzliche Ports oder Dienste zu überprüfen. Zum Beispiel könnten Sie Überprüfungen hinzufügen für:

  • Redis (Port 6379)
  • MongoDB (Port 27017)
  • RDP (Port 3389)

Um eine neue Dienstprüfung hinzuzufügen, fügen Sie einfach eine weitere Zeile mit der Funktion check_port hinzu:

check_port 6379 "Redis Database" "tcp"

Dies demonstriert die Flexibilität von Curl als Werkzeug für das Testen und Überwachen von Netzwerkdiensten.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie man Curl verwendet, um auf verschiedene Ports auf Servern und Netzwerken zuzugreifen. Sie haben:

  • Die Grundlagen von Curl kennengelernt und wie man Ports in URLs angibt
  • Curl verwendet, um mit Webservern auf Standard- und Nicht-Standard-Ports zu interagieren
  • Verschiedene HTTP-Methoden und Header untersucht
  • Mit HTTPS und sicheren Verbindungen gearbeitet
  • Skripte erstellt, um die Portverfügbarkeit und den Servicestatus zu überprüfen

Diese Fähigkeiten sind wertvoll für die Netzwerkfehlerbehebung, die Systemadministration und Sicherheitstests. Die Vielseitigkeit von Curl macht es zu einem unverzichtbaren Werkzeug in Ihrem Command-Line-Toolkit.

Für zusätzliches Üben versuchen Sie:

  • Curl zur Interaktion mit REST-APIs verwenden
  • Verschiedene Verbindungstimeouts und Wiederholungsoptionen testen
  • Fortgeschrittenere Curl-Funktionen wie Cookies, Formularübermittlungen und Proxy-Einstellungen erkunden
  • Das Service-Checker-Skript mit zusätzlichen Protokollen und Fehlerbehandlung erweitern

Denken Sie daran, dass Curl zwar leistungsstark für Tests und grundlegendes Scannen ist, spezialisierte Tools wie Nmap jedoch umfassendere Netzwerk-Scanning-Funktionen für den professionellen Einsatz bieten.