Comment utiliser Curl pour accéder à différents ports

LinuxBeginner
Pratiquer maintenant

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 :

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

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