Introduction
Curl est un outil en ligne de commande puissant qui vous permet de transférer des données en utilisant divers protocoles, notamment HTTP, FTP et SFTP. Dans ce tutoriel, vous apprendrez à utiliser Curl pour accéder à différents ports sur votre serveur ou votre réseau, ce qui vous permettra de dépanner les problèmes de connectivité et de tester la disponibilité des ports.
Ce laboratoire pratique vous guidera à travers les commandes Curl de base et avancées pour l'accès aux ports, vous aidant à comprendre comment les services réseau fonctionnent sur différents ports. À la fin de ce laboratoire, vous serez en mesure d'utiliser Curl avec confiance pour interagir avec les services fonctionnant sur divers ports.
Premiers pas avec Curl
Curl, qui signifie "Client URL", est un outil en ligne de commande pour transférer des données vers ou depuis un serveur. Il prend en charge de nombreux protocoles, notamment HTTP, HTTPS, FTP, SFTP, et bien d'autres. Avant de plonger dans les opérations spécifiques aux ports, assurons-nous que vous comprenez l'utilisation de base de Curl.
Commande Curl de base
Ouvrez votre terminal et tapez la commande suivante pour vérifier si Curl est installé sur votre système :
curl --version
Vous devriez voir une sortie similaire à celle-ci, indiquant la version de Curl et les fonctionnalités prises en charge :
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
Maintenant, essayons une simple requête Curl vers un site web. Tapez la commande suivante :
curl https://example.com
Cette commande télécharge le contenu HTML de example.com et l'affiche dans votre terminal. La sortie sera similaire à :
<!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>
Comprendre les ports HTTP
Les serveurs web fonctionnent généralement sur des ports spécifiques :
- Port 80 pour HTTP (non sécurisé)
- Port 443 pour HTTPS (sécurisé)
Lorsque vous accédez à un site web sans spécifier de port, votre navigateur utilise automatiquement ces ports par défaut. Cependant, avec Curl, vous pouvez spécifier explicitement le port auquel vous connecter.
Essayons d'accéder à un site web sur le port HTTP standard (port 80) :
curl http://example.com:80
La sortie devrait être similaire à votre commande Curl précédente, car le port 80 est le port par défaut pour HTTP.
Maintenant, essayez d'accéder au même site web sur le port HTTPS (port 443) :
curl https://example.com:443
Encore une fois, la sortie devrait être similaire, car le port 443 est le port par défaut pour HTTPS.
Dans ces exemples, nous avons explicitement spécifié les ports dans l'URL en utilisant le format protocole://domaine:port. Cette syntaxe est cruciale lorsque vous travaillez avec des services sur des ports non standard.
Utilisation de Curl avec différents ports
Maintenant que vous comprenez les bases de Curl et la spécification des ports, explorons comment interagir avec différents ports.
Accéder aux ports web non standard
Les serveurs web peuvent fonctionner sur des ports autres que 80 et 443. À des fins de test, configurons un simple serveur web sur le port 8000 en utilisant le serveur HTTP intégré de Python.
Tout d'abord, créez un simple fichier HTML à servir :
echo "<html><body><h1>Hello from port 8000!</h1></body></html>" > ~/project/test.html
Maintenant, accédez au répertoire contenant le fichier et démarrez un simple serveur HTTP sur le port 8000 :
cd ~/project
python3 -m http.server 8000 &
Le & à la fin de la commande exécute le serveur en arrière-plan. Vous devriez voir une sortie comme :
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
Maintenant, utilisez Curl pour accéder à ce serveur sur le port 8000 :
curl http://localhost:8000/test.html
Vous devriez voir le contenu HTML que nous avons créé :
<html>
<body>
<h1>Hello from port 8000!</h1>
</body>
</html>
Lorsque nous avons terminé avec le serveur, nous pouvons l'arrêter en trouvant son ID de processus et en le tuant :
ps aux | grep "python3 -m http.server"
Cela affichera une sortie similaire à :
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
Notez l'ID de processus (PID) dans la deuxième colonne (1234 dans cet exemple), et tuez le processus :
kill $(pgrep -f "python3 -m http.server")
Utilisation de différentes méthodes HTTP
Curl vous permet de spécifier différentes méthodes HTTP en utilisant l'option -X. Essayons une requête POST :
curl -X POST http://example.com
Cela envoie une requête POST à example.com. La plupart des sites web répondront par un message indiquant qu'ils attendent des données différentes pour les requêtes POST.
Ajout d'en-têtes aux requêtes
Lorsque vous travaillez avec des API ou des services spécifiques, vous devez souvent envoyer des en-têtes personnalisés. Vous pouvez le faire avec l'option -H :
curl -H "Content-Type: application/json" http://example.com
Cela envoie une requête avec un en-tête de type de contenu JSON. La réponse dépendra de la façon dont le serveur gère cet en-tête.
Affichage des en-têtes de réponse
Pour voir les en-têtes de réponse ainsi que le contenu, utilisez l'option -i :
curl -i http://example.com
Cela affichera une sortie similaire à :
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>
Les en-têtes fournissent des informations précieuses sur le serveur, le type de contenu, les politiques de mise en cache, et plus encore.
Accès avancé aux ports avec Curl
Maintenant que vous comprenez les bases de l'utilisation de Curl avec différents ports, explorons des techniques plus avancées pour l'accès et les tests de ports.
Tester la disponibilité des ports
Curl peut être utilisé pour vérifier si un port spécifique est ouvert sur un serveur. Lorsqu'un port est ouvert, Curl tentera d'établir une connexion et potentiellement de recevoir des données. Lorsqu'un port est fermé, Curl signalera une erreur.
Testons quelques ports courants :
## Test si le port 80 (HTTP) est ouvert
curl -s -o /dev/null -w "%{http_code}\n" http://example.com:80
Cette commande affichera le code d'état HTTP (généralement 200 si le port est ouvert et que le serveur répond correctement). L'option -s rend Curl silencieux, -o /dev/null redirige la sortie vers nulle part, et -w "%{http_code}\n" affiche uniquement le code d'état HTTP.
Essayons quelques autres ports :
## Test si le port 443 (HTTPS) est ouvert
curl -s -o /dev/null -w "%{http_code}\n" https://example.com:443
Cela devrait renvoyer 200 ou un autre code d'état HTTP, indiquant que le port 443 est ouvert.
Maintenant, testons un port qui est probablement fermé :
## Test si le port 81 (peu courant) est ouvert
curl -s --connect-timeout 5 http://example.com:81
Cette commande échouera probablement avec un message d'erreur comme :
curl: (7) Failed to connect to example.com port 81: Connection refused
ou elle pourrait expirer après 5 secondes (comme spécifié par --connect-timeout) :
curl: (28) Connection timed out after 5001 milliseconds
Accéder aux serveurs FTP
Curl prend en charge plusieurs protocoles, dont FTP. Voyons comment accéder à un serveur FTP :
curl ftp://ftp.gnu.org/gnu/
Cette commande liste le contenu du répertoire à ftp.gnu.org. La sortie pourrait ressembler à :
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
...
Création d'un simple scanner de ports
Créons un simple script Bash pour scanner une plage de ports sur un serveur. Créez un nouveau fichier appelé port_scanner.sh dans votre répertoire de projet :
nano ~/project/port_scanner.sh
Ajoutez le contenu suivant au fichier :
#!/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!"
Enregistrez le fichier en appuyant sur Ctrl+X, puis Y, puis Entrée.
Rendez le script exécutable :
chmod +x ~/project/port_scanner.sh
Maintenant, exécutez le script pour scanner les ports 80-85 sur example.com :
~/project/port_scanner.sh example.com 80 85
La sortie affichera quels ports sont ouverts et lesquels sont fermés :
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!
Ce script simple démontre comment Curl peut être utilisé comme un outil de scan de ports de base. Dans un scénario réel, vous voudriez utiliser des outils spécialisés comme nmap pour une analyse réseau plus complète, mais cet exemple montre la polyvalence de Curl.
Travailler avec HTTPS et les connexions sécurisées
Dans cette étape, nous allons explorer comment utiliser Curl avec HTTPS et gérer diverses options liées à la sécurité.
Comprendre les connexions HTTPS
Les connexions HTTPS utilisent les protocoles SSL/TLS pour sécuriser la transmission des données. Lorsque vous utilisez Curl pour vous connecter à un site HTTPS, il vérifie par défaut le certificat SSL du serveur.
Essayons de nous connecter à un site web sécurisé :
curl https://www.google.com
Cette commande se connecte au serveur HTTPS de Google et renvoie le contenu HTML.
Gérer la vérification du certificat SSL
Parfois, vous devrez peut-être vous connecter à un serveur avec un certificat auto-signé ou invalide. Dans de tels cas, vous pouvez utiliser l'option -k ou --insecure pour ignorer la validation du certificat :
curl -k https://www.google.com
Cette commande se connectera au site même si le certificat ne peut pas être validé. La sortie devrait être similaire à la commande précédente.
Afficher les informations du certificat
Pour examiner le certificat SSL d'un site web, utilisez l'option -v (verbose) :
curl -v https://www.google.com > /dev/null
Cette commande affichera des informations détaillées sur la poignée de main SSL et le certificat tout en envoyant le contenu réel vers /dev/null. La sortie comprend les détails du certificat :
* 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.
Utiliser des versions TLS spécifiques
Vous pouvez spécifier quelle version TLS utiliser avec l'option --tlsv1.X :
## Force TLS 1.2
curl --tlsv1.2 https://www.google.com > /dev/null
Cela garantit que Curl utilise TLS 1.2 pour la connexion.
Télécharger des fichiers en toute sécurité
Curl peut télécharger des fichiers à partir de sources HTTPS. Téléchargeons un fichier et enregistrons-le avec l'option -o :
curl -o ~/project/google_logo.png https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png
Cette commande télécharge le logo de Google et l'enregistre sous le nom google_logo.png dans votre répertoire de projet. Vérifiez si le fichier existe :
ls -l ~/project/google_logo.png
Vous devriez voir une sortie comme :
-rw-r--r-- 1 labex labex 5969 Jun 7 12:34 /home/labex/project/google_logo.png
Spécifier des en-têtes personnalisés pour HTTPS
Lorsque vous travaillez avec des API sécurisées, vous devez souvent inclure des en-têtes d'authentification. Voici comment procéder :
curl -H "Authorization: Bearer your_token_here" https://api.example.com
Remplacez your_token_here par un jeton réel si vous en avez un. Sinon, cette commande renverra probablement une erreur ou un message non autorisé du serveur.
Accéder à HTTPS sur des ports non standard
Les services HTTPS peuvent fonctionner sur des ports autres que 443. Pour accéder à de tels services, spécifiez le port dans l'URL :
curl https://example.com:8443
Cette commande tente de se connecter à un service HTTPS sur le port 8443. Puisque example.com n'a pas de service sur ce port, vous verrez probablement une erreur :
curl: (7) Failed to connect to example.com port 8443: Connection refused
Cela démontre que Curl peut tenter de se connecter à n'importe quel port en utilisant n'importe quel protocole, ce qui en fait un outil polyvalent pour tester les services réseau.
Création d'un script complet de vérification des ports
Dans cette dernière étape, nous allons créer un script plus sophistiqué qui utilise Curl pour vérifier les services courants sur un serveur cible.
Comprendre les ports de service courants
Différents services fonctionnent généralement sur des ports standard :
- Web (HTTP) : Port 80
- Web sécurisé (HTTPS) : Port 443
- FTP : Port 21
- SSH : Port 22
- SMTP (Email) : Port 25
- DNS : Port 53
- Base de données (MySQL) : Port 3306
- Base de données (PostgreSQL) : Port 5432
Créons un script qui vérifie ces ports courants sur un hôte donné.
Création du script de vérification des services
Créez un nouveau fichier appelé service_checker.sh dans votre répertoire de projet :
nano ~/project/service_checker.sh
Ajoutez le contenu suivant au fichier :
#!/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!"
Enregistrez le fichier en appuyant sur Ctrl+X, puis Y, puis Entrée.
Rendez le script exécutable :
chmod +x ~/project/service_checker.sh
Exécution du vérificateur de services
Maintenant, exécutez le script pour vérifier les services sur un site web bien connu :
~/project/service_checker.sh example.com
Vous verrez une sortie similaire à celle-ci :
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!
Cette sortie montre qu'example.com a des serveurs web fonctionnant sur les ports 80 et 443, mais que d'autres services courants ne sont pas accessibles publiquement.
Comprendre les résultats
Les résultats de notre script fournissent des informations précieuses :
Services disponibles : Ces ports sont ouverts et répondent aux requêtes, indiquant que les services correspondants sont en cours d'exécution et accessibles.
Services non disponibles : Ces ports peuvent être :
- Fermés (aucun service en cours d'exécution)
- Filtrés par un pare-feu (firewall)
- En cours d'exécution mais configurés pour ne pas répondre aux requêtes génériques
Ces informations sont utiles pour :
- Les administrateurs réseau vérifiant la disponibilité des services
- Les professionnels de la sécurité menant une reconnaissance initiale
- Les développeurs vérifiant que leurs services sont correctement configurés
Modification du script
N'hésitez pas à modifier le script pour vérifier des ports ou des services supplémentaires. Par exemple, vous pourriez ajouter des vérifications pour :
- Redis (Port 6379)
- MongoDB (Port 27017)
- RDP (Port 3389)
Pour ajouter une nouvelle vérification de service, ajoutez simplement une autre ligne avec la fonction check_port :
check_port 6379 "Redis Database" "tcp"
Cela démontre la flexibilité de Curl en tant qu'outil de test et de surveillance des services réseau.
Résumé
Dans ce tutoriel, vous avez appris à utiliser Curl pour accéder à différents ports sur des serveurs et des réseaux. Vous avez :
- Appris les bases de Curl et comment spécifier les ports dans les URL
- Utilisé Curl pour interagir avec des serveurs web sur des ports standard et non standard
- Exploré différentes méthodes et en-têtes HTTP
- Travaillé avec HTTPS et les connexions sécurisées
- Créé des scripts pour vérifier la disponibilité des ports et l'état des services
Ces compétences sont précieuses pour le dépannage réseau, l'administration système et les tests de sécurité. La polyvalence de Curl en fait un outil essentiel dans votre boîte à outils en ligne de commande.
Pour une pratique supplémentaire, essayez :
- D'utiliser Curl pour interagir avec les API REST
- De tester différents délais d'attente de connexion et options de nouvelle tentative
- D'explorer des fonctionnalités plus avancées de Curl comme les cookies, les soumissions de formulaires et les paramètres de proxy
- D'améliorer le script de vérification des services avec des protocoles supplémentaires et la gestion des erreurs
N'oubliez pas que bien que Curl soit puissant pour les tests et l'analyse de base, des outils spécialisés comme Nmap fournissent des capacités d'analyse réseau plus complètes pour un usage professionnel.
