glossaire-linux

Réseau

Tester la connectivité, résoudre des noms, inspecter les interfaces, voir qui écoute sur quel port, télécharger des ressources. Les outils legacy (ifconfig, netstat) coexistent encore, mais ip et ss sont désormais à privilégier.

Identité de la machine

Comment la machine se nomme, comment elle se présente sur le réseau, ses adresses locales.

hostname

Afficher ou définir le nom de la machine

hostname affiche le nom de la machine, tel que le noyau le connaît. Sur une distribution systemd, hostnamectl le modifie de façon permanente.

$ hostname
srv-prod-01
$ hostname -I
192.168.1.42 10.0.0.5
Avec l'implémentation net-tools, affiche les adresses configurées sur les interfaces, en excluant notamment la loopback et les adresses IPv6 link-local. Pour inspecter toutes les interfaces en détail, utiliser ip address.
$ hostname -f
Demande le nom canonique obtenu par la résolution du nom local. Le résultat dépend de DNS et de /etc/hosts ; hostname -f ne garantit pas qu'un FQDN correctement configuré existe.
# hostnamectl set-hostname nouveau-nom
Modification persistante via systemd (édite /etc/hostname).
Trois noms distincts : hostnamectl distingue le static (nom DNS technique), le pretty (libellé humain, accents et espaces autorisés), et le transient (modifiable à chaud sans redémarrage). hostnamectl set-hostname --pretty "Serveur de prod n°1" définit le pretty, visible dans hostnamectl status et exposé aux outils desktop type GNOME ou Cockpit.

Voir aussi : ip dig /etc

hostnamectl

Afficher et définir durablement le nom et l'identité de la machine

hostnamectl pilote systemd-hostnamed : il change le nom de la machine de façon permanente (il écrit /etc/hostname) et affiche au passage un résumé utile : système, noyau, architecture, type de machine.

Sous-commandes principales

statusRésumé complet (par défaut sans argument).
hostname NOMDéfinit le nom de la machine ; set-hostname sur les versions plus anciennes.
hostname --pretty "NOM"Définit le nom lisible, qui accepte espaces et accents.
chassis TYPEType de machine : server, vm, laptop…
$ hostnamectl
Static hostname:  web01
Icon name:        computer-vm
Chassis:          vm
Operating System: Fedora Linux 44 (Server Edition)
Kernel:           Linux 7.2.11-200.fc44.x86_64
Architecture:     x86-64
La ligne Static hostname est le nom permanent. Le résumé affiche aussi l'identifiant de la machine, à ne pas diffuser.
# hostnamectl hostname web01.exemple.fr
Change le nom immédiatement et durablement, sans redémarrage. Penser à mettre à jour /etc/hosts si le nom y figure.

Voir aussi : hostname /etc localectl

Interfaces réseau

Configurer et inspecter les cartes réseau, leurs adresses, leur liaison physique et la table de routage.

ip

Outil moderne de configuration réseau

Issu du paquet iproute2, ip remplace ifconfig, route et arp avec une syntaxe sous-commande cohérente.

Sous-commandes principales

ip a (addr)Liste les adresses IP de toutes les interfaces.
ip l (link)État des interfaces (UP/DOWN, MAC).
ip r (route)Table de routage.
ip n (neighbor)Cache ARP/NDP.
$ ip a
Vue d'ensemble : interfaces, adresses IPv4 et IPv6.
$ ip a show eth0
Détails d'une interface précise.
$ ip route
default via 192.168.1.1 dev eth0
192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.42
Route par défaut + réseaux directement connectés.
# ip link set eth0 up
ip addr add 192.168.1.50/24 dev eth0
ip route add default via 192.168.1.1
Configuration manuelle complète. Non persistante : utiliser NetworkManager, netplan ou /etc/network/interfaces pour rendre cela durable.

Voir aussi : nmcli ss ethtool ping

ifconfig

Configuration réseau, version classique

Outil historique du paquet net-tools, désormais déprécié au profit de ip. Reste installé par habitude sur de nombreux systèmes.

$ ifconfig
ifconfig eth0
Recommandation : apprendre plutôt ip a et ip r : on tombe sur ifconfig de moins en moins souvent.

Voir aussi : ip netstat

nmcli

Pilote en ligne de commande de NetworkManager

nmcli pilote NetworkManager, utilisé notamment sur Fedora et de nombreux postes de travail. Un serveur Ubuntu peut utiliser Netplan avec systemd-networkd ou NetworkManager selon sa configuration : vérifier le gestionnaire actif. nmcli crée des profils généralement persistants dans /etc/NetworkManager/system-connections/.

Sous-commandes principales

device (alias d)État des interfaces physiques. nmcli d = vue d'ensemble.
connection (alias c)Gestion des profils. nmcli c show, up, down, add, modify, delete.
general (alias g)État global (online/offline, hostname).
radioAllume/éteint wifi et WWAN. nmcli radio wifi off.
monitorSuit les événements réseau en temps réel.
$ nmcli d
DEVICE  TYPE      STATE      CONNECTION
wlan0   wifi      connected  Freebox-A1B2
eth0    ethernet  connected  Wired connection 1
lo      loopback  unmanaged  --
Vue rapide : quelles interfaces existent, quel est leur état, à quel profil chacune est associée. unmanaged = NetworkManager ignore (la loopback, ou tout ce qui est listé dans NotManaged).
$ nmcli c show
Liste tous les profils de connexion enregistrés (actifs ou non). nmcli c show 'Mon VPN' détaille un profil précis : interface cible, IP, DNS, route, etc.
# nmcli --ask device wifi connect Freebox-A1B2
Se connecter à un réseau Wi-Fi. --ask demande le mot de passe de façon interactive au lieu de l'inscrire dans la commande, où il pourrait rester dans l'historique du shell ou être visible dans la liste des processus. NetworkManager crée automatiquement un profil.
$ nmcli d wifi list
IN-USE  BSSID              SSID          MODE   CHAN  RATE        SIGNAL  SECURITY
*       AA:BB:CC:DD:EE:FF  Freebox-A1B2  Infra  6     270 Mbit/s  85      WPA2
        11:22:33:44:55:66  voisin        Infra  11    270 Mbit/s  42      WPA2
Scan des réseaux wifi disponibles. * dans IN-USE = celui auquel on est connecté.
# nmcli c add type ethernet con-name srv-static ifname eth0 \
    ipv4.method manual ipv4.addresses 192.168.1.50/24 \
    ipv4.gateway 192.168.1.1 ipv4.dns "1.1.1.1,9.9.9.9"
nmcli c up srv-static
Crée et active un profil IPv4 statique. L'activation peut interrompre une connexion distante : utiliser les noms et adresses adaptés au serveur. Pour revenir à DHCP, régler ipv4.method auto et vider les adresses, passerelle et DNS statiques si l'on ne veut pas les conserver ; vérifier aussi ipv4.ignore-auto-dns avant d'activer à nouveau le profil.
# nmcli c modify Freebox-A1B2 ipv4.dns '1.1.1.1 9.9.9.9' ipv4.ignore-auto-dns yes
Modifie les DNS IPv4 enregistrés dans le profil et ignore ceux fournis automatiquement. Réactiver le profil avec nmcli connection up Freebox-A1B2 ou utiliser nmcli device reapply sur l'interface si le changement est pris en charge ; une modification du profil n'est pas toujours appliquée immédiatement à la connexion active. Adapter aussi IPv6 si nécessaire.
nmcli vs nmtui : nmtui est une interface textuelle de NetworkManager (paquet NetworkManager-tui sur Fedora/RHEL). Elle couvre les opérations courantes mais n'expose pas toutes les possibilités de nmcli.

Voir aussi : ip systemctl dig

ethtool

Inspecter et régler une carte réseau : liaison, vitesse, pilote

ethtool interroge le pilote d'une carte réseau filaire : présence de la liaison, vitesse négociée, compteurs d'erreurs, fonctions déchargées sur la carte (offload). C'est le premier contrôle quand une machine est lente ou perd sa connexion alors que la configuration IP semble correcte.

Options principales

IFACESans option : vitesse, duplex, auto-négociation et état de la liaison.
-i IFACEPilote, version du pilote et du firmware.
-S IFACEStatistiques détaillées de la carte, dont les erreurs et les paquets perdus.
-k IFACEFonctions de déchargement (offload) et leur état.
-K IFACE FONCTION on|offActive ou désactive une fonction de déchargement.
-p IFACEFait clignoter la carte pour la repérer physiquement.
# ethtool eth0
Settings for eth0:
        Speed: 1000Mb/s
        Duplex: Full
        Auto-negotiation: on
        Link detected: yes
Une vitesse de 100Mb/s sur un réseau gigabit pointe souvent vers un câble ou un port défectueux.
$ ethtool -i eth0
Indique le pilote utilisé, à vérifier avant de chercher un bug connu ou une mise à jour de firmware.
# ethtool -S eth0 | grep -iE 'err|drop'
Des compteurs d'erreurs qui augmentent signalent un problème physique ou de pilote plutôt qu'un problème de configuration.
Interfaces virtuelles et Wi-Fi : les interfaces virtuelles (ponts, VLAN, cartes de machines virtuelles) et les cartes Wi-Fi renvoient peu d'informations. Pour le Wi-Fi, utiliser iw dev et nmcli device wifi.

Voir aussi : ip nmcli tcpdump

Diagnostic

Vérifier qu'une machine est joignable et par quel chemin, mesurer le débit réel et observer le trafic qui circule.

ping

Tester la connectivité ICMP avec un hôte

Envoie des paquets ICMP echo request et mesure le temps de réponse. Outil d'urgence pour savoir si « ça passe ».

Options

-c NS'arrête après N requêtes (sinon infini, à couper avec Ctrl+C).
-i NIntervalle entre paquets en secondes.
-W NDélai d'attente d'une réponse, en secondes.
-s NTaille de la charge utile.
$ ping -c 4 google.com
PING google.com (142.250.74.46): 56 data bytes
64 bytes from 142.250.74.46: icmp_seq=0 ttl=116 time=12.4 ms
...
4 packets transmitted, 4 packets received, 0.0% packet loss
round-trip min/avg/max = 12.1/12.6/13.2 ms
$ ping -c 1 -W 2 192.168.1.10
Test rapide en une tentative avec timeout court — utile dans un script.

Voir aussi : traceroute ip dig

traceroute · tracepath · mtr

Suivre la route empruntée par les paquets

Liste tous les routeurs traversés entre vous et la destination, avec leur temps de réponse. mtr combine ping et traceroute dans une vue rafraîchie en continu — beaucoup plus utile pour diagnostiquer.

$ traceroute 1.1.1.1
Trace les sauts jusqu'au DNS de Cloudflare.
$ mtr google.com
Vue temps réel : utile pour voir où la latence est introduite.

Voir aussi : ping tcpdump ip

tcpdump

Capturer et afficher le trafic réseau

tcpdump affiche les paquets qui passent sur une interface, filtrés par une expression (hôte, port, protocole). Il peut aussi enregistrer une capture au format pcap, à ouvrir ensuite dans Wireshark. La capture nécessite les droits root.

Options principales

-i IFACEInterface à écouter ; any pour toutes.
-nnN'effectue aucune résolution de noms d'hôtes ni de ports : sortie plus rapide et plus lisible.
-c NS'arrête après N paquets.
-w FICHIEREnregistre les paquets bruts dans un fichier pcap.
-r FICHIERRelit une capture enregistrée.
-AAffiche le contenu des paquets en texte, utile pour HTTP non chiffré.
# tcpdump -i eth0 -nn port 53
Montre les requêtes et réponses DNS en direct : on voit quel serveur est interrogé et s'il répond.
# tcpdump -i any -nn host 192.168.1.20 and tcp port 443
Les filtres se combinent avec and, or et not.
# tcpdump -i eth0 -nn -c 1000 -w capture.pcap
Enregistre 1000 paquets pour une analyse ultérieure, avec tcpdump -nn -r capture.pcap ou Wireshark.
Données sensibles : une capture contient tout ce qui circule en clair : identifiants, cookies, contenu des requêtes. Filtrer au plus juste, protéger le fichier pcap et le supprimer après analyse.

Voir aussi : ss nmap ethtool

iperf3

Mesurer le débit réel entre deux machines

iperf3 mesure le débit entre un serveur et un client en faisant circuler des données de test. Il isole le réseau des disques et des applications : si iperf3 est rapide mais un transfert de fichier lent, le problème n'est pas le réseau. Les deux machines doivent avoir iperf3 installé.

Options principales

-sMode serveur, en écoute sur le port 5201.
-c HÔTEMode client, vers le serveur indiqué.
-RInverse le sens : le serveur envoie, le client reçoit.
-P NOuvre N flux en parallèle.
-t SECONDESDurée du test (10 secondes par défaut).
-u -b DÉBITTest en UDP au débit demandé, par exemple -b 100M ; mesure aussi la gigue et les pertes.
$ iperf3 -s
À lancer sur la première machine. Arrêter avec Ctrl+C après les mesures.
$ iperf3 -c 192.168.1.10 -t 20
[ ID] Interval           Transfer     Bitrate         Retr
[  5]   0.00-20.00  sec  2.19 GBytes   941 Mbits/sec    0   sender
[  5]   0.00-20.00  sec  2.19 GBytes   939 Mbits/sec        receiver
Environ 940 Mbit/s est le maximum pratique sur un lien gigabit. La colonne Retr compte les retransmissions TCP.
$ iperf3 -c 192.168.1.10 -R
Mesure le sens inverse : un débit très différent dans les deux sens oriente vers un problème de duplex ou de câble.
Ne pas laisser le serveur exposé : ouvrir le port 5201 seulement pendant le test et arrêter iperf3 -s ensuite. N'importe quel client pourrait sinon saturer le lien.

Voir aussi : ping traceroute ethtool

DNS

Résoudre un nom en IP (et inversement), inspecter les enregistrements, retrouver le titulaire d'un domaine ou d'une adresse.

dig

Outil DNS le plus complet

dig (paquet dnsutils ou bind-utils) interroge des serveurs DNS et affiche tous les détails. C'est l'outil de référence pour tout diagnostic DNS.

$ dig example.com
Requête A complète avec sections answer, authority, additional.
$ dig +short example.com
93.184.216.34
+short ne renvoie que la réponse — pratique en script.
$ dig MX gmail.com +short
Enregistrements MX (serveurs mail) du domaine.
$ dig @8.8.8.8 example.com
Force la requête vers un serveur DNS précis (ici Google).
$ dig +trace example.com
Trace toute la délégation, depuis les root servers jusqu'à la zone finale.

Voir aussi : host resolvectl nslookup

resolvectl

Diagnostiquer le DNS géré par systemd-resolved

resolvectl interroge et inspecte le service systemd-resolved. Il n'est disponible que si ce service est installé et actif ; sur d'autres configurations, consulter /etc/resolv.conf ou utiliser dig.

$ resolvectl status
Affiche les DNS et domaines de recherche configurés, globalement et par interface.
$ resolvectl query example.com
Demande la résolution à systemd-resolved et affiche les résultats ainsi que leur source.
$ resolvectl statistics
Affiche les statistiques du cache DNS et des requêtes.

Voir aussi : dig systemctl

nslookup

Résolution DNS, version simple

Plus ancien et moins informatif que dig, mais souvent installé par défaut.

$ nslookup example.com
$ nslookup -type=MX exemple.fr
Interroge un type d'enregistrement précis : ici les serveurs de messagerie du domaine.
$ nslookup exemple.fr 1.1.1.1
Pose la question à un serveur DNS choisi plutôt qu'au résolveur de la machine : utile pour savoir si le problème vient du DNS local.

Voir aussi : dig host

host

Résolution DNS, version concise

host interroge le DNS et affiche une réponse courte, une ligne par enregistrement. Plus lisible que dig pour une vérification rapide, mais moins détaillé.

$ host wikipedia.org
wikipedia.org has address 208.80.154.224
wikipedia.org has IPv6 address 2620:0:861:ed1a::1
wikipedia.org mail is handled by 10 mx2001.wikimedia.org.
$ host -t MX exemple.fr
Affiche un seul type d'enregistrement, une ligne par serveur de messagerie.
$ host 203.0.113.42
Résolution inverse : retrouve le nom associé à une adresse IP, par exemple vue dans un journal.

Voir aussi : dig nslookup resolvectl

whois

Interroger les registres : propriétaire d'un domaine ou d'une adresse IP

whois interroge les bases publiques des registres : pour un domaine, son registrar, ses dates de création et d'expiration et ses serveurs DNS ; pour une adresse IP, le réseau qui la détient et le contact à prévenir en cas d'abus. Les données personnelles des titulaires sont souvent masquées.

Options principales

DOMAINE ou IPLe serveur à interroger est choisi automatiquement.
-h SERVEURInterroge un serveur whois précis.
-HMasque les mentions légales en tête de réponse.
$ whois exemple.fr | grep -iE 'registrar|expir|nserver'
Retrouve le registrar, la date d'expiration et les serveurs DNS d'un domaine : utile avant un renouvellement ou une migration.
$ whois 203.0.113.42 | grep -iE 'netname|country|abuse'
Identifie le réseau d'une adresse vue dans les journaux, et l'adresse de contact pour signaler un abus.

Voir aussi : dig host fail2ban-client

Ports et connexions

Voir qui écoute, qui est connecté et sur quel port, et relayer un port vers une autre destination.

ss

Inspecter les sockets (remplaçant moderne de netstat)

ss affiche les sockets ouverts : ports en écoute, connexions établies, processus propriétaires. Il remplace netstat et lit directement les informations du noyau.

Options

-tConnexions TCP.
-uConnexions UDP.
-lSockets en écoute uniquement.
-nAffiche les ports numériques (sans résolution).
-pAffiche le processus qui possède le socket (souvent sudo requis).
$ ss -tuln
Netid State  Recv-Q Send-Q Local Address:Port  Peer Address:Port
tcp   LISTEN 0      128    0.0.0.0:22          0.0.0.0:*
tcp   LISTEN 0      128    127.0.0.1:631       0.0.0.0:*
Tous les ports TCP/UDP en écoute. Le combo le plus utile.
# ss -tlnp
Avec -p en root, on voit aussi quel processus écoute.
$ ss -t state established
Connexions TCP actuellement établies.

Voir aussi : netstat lsof nc nmap

netstat

Outil legacy, équivalent de ss

netstat appartient au paquet net-tools, qui n'est plus installé par défaut sur de nombreuses distributions. Il reste courant dans les documentations ; son équivalent moderne est ss.

$ netstat -tulnp

Les options sont presque identiques à ss. Préférez ss sur les systèmes modernes (plus rapide, mieux maintenu).

$ netstat -rn
Table de routage sans résolution de noms, équivalent de ip route.
$ netstat -i
Compteurs par interface, dont les erreurs et les paquets perdus ; équivalent moderne : ip -s link.

Voir aussi : ss ifconfig

nc (netcat)

Couteau suisse TCP/UDP : tester, écouter, transférer

nc ouvre, écoute ou se connecte à un port TCP ou UDP, et fait passer son stdin/stdout à travers la connexion. Outil universel pour tester un service, écouter un port en mode debug, transférer un fichier improvisé, ou envoyer une requête brute.

Options principales

-lMode listen : ouvre un port et attend une connexion.
-zMode zero-I/O : se connecte juste pour tester si le port est ouvert (combiner avec -v).
-vVerbeux (affiche le résultat de la tentative).
-uUDP au lieu de TCP.
-w SECTimeout en secondes.
-p PORT(côté client) Port source à utiliser.
$ nc -zv api.example.test 443
Connection to api.example.test 443 port [tcp/https] succeeded!
Test minimal de joignabilité d'un port. Plus précis que ping (qui n'utilise que ICMP) — vérifie qu'un service écoute vraiment.
$ nc -l 8080
Ouvre un faux serveur TCP sur le port 8080. Tout ce qu'un client lui envoie s'affiche sur stdout. Pratique pour voir exactement ce qu'envoie une application qui « ne marche pas avec mon API ».
$ printf 'GET / HTTP/1.0\r\nHost: example.test\r\n\r\n' | nc example.test 80
Requête HTTP brute. Permet de voir les headers exacts renvoyés sans la magie d'un client comme curl. Le \r\n est obligatoire en HTTP.
$ nc -l 5000 > recu.tar.gz
À lancer uniquement sur la destination, avec une implémentation compatible nc.openbsd, puis utiliser depuis la source : nc -N dst-host 5000 < archive.tar.gz. -N ferme le côté écriture à la fin de stdin. Adapter aux variantes de netcat ; -w est un délai d'inactivité, pas une preuve de transfert complet. Le transport n'est ni chiffré ni authentifié ; vérifier l'intégrité du fichier et limiter l'écoute au réseau prévu.
Variantes incompatibles : il existe au moins trois implémentations (nc.openbsd, nc.traditional, ncat du paquet nmap) avec des drapeaux légèrement différents. Sur les distros modernes ncat est souvent recommandé : mêmes idées, options homogènes, support TLS via --ssl.

Voir aussi : ss curl nmap

socat

Relier deux flux de données : sockets, fichiers, ports série

socat relie deux extrémités et fait circuler les données entre elles : un port TCP, un socket Unix, un fichier, un terminal, une connexion TLS. C'est un nc plus complet, utile pour rediriger un port ou exposer un socket local le temps d'un test.

Syntaxe

socat [options] ADRESSE1 ADRESSE2
socat - TCP:hote:80                                  # comme nc
socat TCP-LISTEN:8080,fork TCP:127.0.0.1:80          # relais de port
socat TCP-LISTEN:2375,bind=127.0.0.1 UNIX:/run/app.sock   # socket Unix -> TCP local

Adresses courantes

-L'entrée et la sortie standard.
TCP:HÔTE:PORTSe connecte à un port TCP.
TCP-LISTEN:PORT,forkÉcoute sur un port ; fork accepte plusieurs clients.
UNIX-CONNECT:CHEMINSe connecte à un socket Unix.
OPENSSL:HÔTE:PORTConnexion chiffrée TLS.
$ socat TCP-LISTEN:8080,fork,reuseaddr TCP:192.168.1.20:80
Relaie le port 8080 local vers le port 80 d'une autre machine, par exemple pour joindre temporairement un service depuis un réseau qui n'y a pas accès.
$ printf 'GET / HTTP/1.1\r\nHost: exemple.fr\r\nConnection: close\r\n\r\n' | socat - OPENSSL:exemple.fr:443
Envoie une requête HTTP brute sur une connexion TLS et affiche la réponse, en-têtes compris. L'en-tête Host est nécessaire : un serveur qui héberge plusieurs sites répond sinon par une erreur ou par son site par défaut.
Relais ouvert : un relais TCP-LISTEN écoute par défaut sur toutes les interfaces. Ajouter bind=127.0.0.1 pour le limiter à la machine, et l'arrêter après usage.

Voir aussi : nc ssh ss

HTTP et téléchargement

Faire des requêtes HTTP en ligne de commande.

curl

Couteau suisse des requêtes HTTP/HTTPS/FTP

curl envoie une requête vers une URL et affiche la réponse. Il gère HTTP, HTTPS, FTP et de nombreux autres protocoles, et sert autant à télécharger qu'à tester une API ou un serveur web.

Options principales

-IHEAD : récupère uniquement les en-têtes.
-LSuit les redirections.
-o fichierSauvegarde dans un fichier précis.
-OSauvegarde sous le nom du fichier distant.
-X METHODMéthode HTTP (POST, PUT, DELETE…).
-d 'data'Corps de la requête.
-H 'Header: ...'Ajoute un en-tête.
-u user:passAuthentification basic.
-kIgnore les erreurs de certificat (à éviter en prod).
-sSilencieux (pas de barre de progression).
$ curl https://api.github.com/users/torvalds
Récupère un JSON depuis l'API GitHub.
$ curl -I https://example.com
En-têtes HTTP uniquement, utile pour vérifier les redirections, le serveur, le cache.
$ curl -X POST -H "Content-Type: application/json" \
     -d '{"name":"alice"}' https://api.example.com/users
POST JSON typique vers une API REST.
$ curl -LO https://example.com/archive.tar.gz
Télécharge le fichier en suivant les redirections, en gardant son nom.

Voir aussi : wget openssl jq

wget

Téléchargement par défaut, optimisé pour les gros fichiers

wget télécharge des fichiers depuis le web, peut reprendre un transfert interrompu et aspirer un site de façon récursive. Contrairement à curl, il écrit dans un fichier par défaut.

Options

-cReprend un téléchargement interrompu.
-rRécursif (aspirateur de site, à utiliser avec précaution).
-O fichierForce le nom du fichier de sortie.
--limit-rate=200kLimite la bande passante.
-qSilencieux.
$ wget https://example.com/iso/distribution.iso
Téléchargement classique avec barre de progression.
$ wget -c https://example.com/gros-fichier.zip
Reprend le téléchargement où il s'était arrêté (très utile sur connexion instable).

Voir aussi : curl scp

Accès distant

Le trio standard pour se connecter, exécuter, copier des fichiers à travers un canal chiffré : ssh, scp et sftp. Tous reposent sur OpenSSH et partagent la même configuration (~/.ssh/config, clés dans ~/.ssh/) ; ssh-agent garde une clé déverrouillée le temps d'une session.

ssh

Shell sécurisé : se connecter à un hôte distant et y exécuter des commandes

Ouvre une session interactive ou exécute une commande unique sur l'hôte distant, le tout dans un canal chiffré. Authentification par mot de passe ou (recommandé) par clé publique. ssh sait aussi forwarder des ports et un agent — autant de cas d'usage en administration.

Syntaxe

ssh user@hote                          # session interactive
ssh user@hote 'commande arg1'          # execution distante d'une commande puis sortie
ssh -p 2222 user@hote                  # port non standard
ssh -i ~/.ssh/cle_specifique user@hote # cle identifiee explicitement
ssh -L 8080:localhost:80 user@hote     # tunnel : 8080 local -> 80 sur hote distant

Options utiles

-p PORTPort TCP (défaut 22).
-i FICHIERClé privée à utiliser pour l'authentification.
-AForward de l'agent SSH : permet de rebondir sur d'autres hôtes sans recopier les clés.
-L LOCAL:HOTE:PORTTunnel local : ce qui arrive sur le port LOCAL de la machine est transmis à HOTE:PORT depuis le serveur distant.
-NPas de commande distante (juste le tunnel). Souvent combiné avec -f pour passer en arrière-plan.
-v / -vv / -vvvVerbose. Pour déboguer un échec d'authentification ou un timeout.
$ ssh-keygen -t ed25519
ssh-copy-id user@serveur.test
Génère une paire de clés puis copie une clé publique sur le serveur. Vérifier le fichier choisi si plusieurs clés existent : ssh-copy-id -i ~/.ssh/id_ed25519.pub user@serveur.test. Le serveur doit autoriser cette méthode ; une passphrase de clé ou un second facteur peut encore être demandé.
$ ssh deploy@web 'systemctl status nginx'
Exécute une seule commande à distance et revient. Pratique dans les scripts de déploiement ou de monitoring : pas de session interactive à fermer.
$ ssh -t deploy@web 'sudo systemctl restart nginx'
-t alloue un pseudo-terminal pour une commande distante interactive. C'est utile si sudo doit lire un mot de passe ou si la politique exige un TTY ; une règle NOPASSWD peut fonctionner sans TTY. Vérifier la politique de l'hôte plutôt que supposer que toute commande sudo distante en exige un.
$ ssh -o ExitOnForwardFailure=yes -L 127.0.0.1:5432:localhost:5432 -N -f db.test
Écoute explicitement sur 127.0.0.1:5432 et transmet vers localhost:5432 vu depuis db.test. Si ce port local est libre et le tunnel établi, psql -h 127.0.0.1 -p 5432 traverse SSH. ExitOnForwardFailure détecte l'échec de la mise en place du forwarding, pas une panne ultérieure de PostgreSQL.
Configurer ses hôtes : les déclarer dans ~/.ssh/config évite de retaper les options. Une entrée Host web avec HostName, User, Port, IdentityFile permet ensuite de simplement ssh web.

Voir aussi : scp sftp rsync

scp

Copie de fichiers à travers SSH

Variante de cp qui transfère par SSH, dans un sens ou dans l'autre. Syntaxe proche : la source ou la destination peut être préfixée par user@hote:. Pour des transferts répétés, beaucoup de sysadmins préfèrent rsync qui ne recopie que ce qui a changé.

Syntaxe

scp [options] SOURCE DEST
scp fichier.txt user@hote:/tmp/                # local -> distant
scp user@hote:/var/log/app.log .               # distant -> local
scp -r dossier/ user@hote:/srv/                # recursif
scp -P 2222 fichier user@hote:/tmp/            # port non standard (P majuscule !)

Options principales

-rRécursif (copier un dossier entier).
-P PORTPort SSH (attention P majuscule, contrairement à ssh).
-i FICHIERClé privée à utiliser.
-pPréserve dates et permissions de la source.
-CCompresse pendant le transfert.
$ scp deploy@web:/var/log/nginx/access.log ./logs/
Récupère un log distant dans le dossier local ./logs/. Le : sépare l'hôte du chemin distant. Si on omet le chemin distant après :, scp prend le répertoire personnel comme racine.
$ scp -r ./build/ deploy@web:/srv/app/
Pousse un dossier complet vers le serveur. Pour des déploiements répétés, rsync -av --delete serait plus efficace (transfert delta).
Évolution : depuis OpenSSH 9.0 (2022), scp utilise par défaut le protocole SFTP en interne. Le comportement général reste identique mais certains caractères spéciaux dans les noms se gèrent mieux.

Voir aussi : ssh sftp rsync

sftp

Client de transfert interactif sur SSH

sftp ressemble à un FTP classique mais passe par SSH (donc chiffré et authentifié pareil). Mode interactif avec commandes ls, cd, get, put — pratique pour explorer un système distant et y déposer ou récupérer des fichiers à la demande.

Commandes interactives courantes

ls / llsListe le répertoire distant / local.
cd / lcdChange de répertoire distant / local.
pwd / lpwdAffiche le répertoire courant distant / local.
get FICHIERTélécharge depuis le distant. get -r DOSSIER pour récursif.
put FICHIEREnvoie vers le distant. put -r DOSSIER idem.
bye / quitSort du client.
$ sftp deploy@web
Connected to web.
sftp> cd /srv/uploads
sftp> ls *.zip
sftp> get archive.zip
sftp> bye
Session interactive type. Le préfixe l sur les commandes (lls, lcd, lpwd) cible le système local plutôt que le distant — pratique pour ajuster l'endroit où atterrissent les fichiers téléchargés.
$ sftp -b commandes.txt user@hote
Mode batch : exécute la liste de commandes depuis un fichier puis sort. Utile pour scripter des transferts non triviaux sans passer par scp répété.

Voir aussi : ssh scp rsync

ssh-keygen · ssh-copy-id

Authentification par clé : se connecter en SSH sans mot de passe

L'authentification par clé remplace le mot de passe par une paire privée (gardée sur le client, jamais partagée) / publique (déposée sur le serveur dans ~/.ssh/authorized_keys). Plus sûr qu'un mot de passe — résistant au brute-force — et indispensable pour automatiser transferts et déploiements sans saisie interactive.

$ ssh-keygen -t ed25519 -C "dev@poste"
Generating public/private ed25519 key pair.
Enter file in which to save the key (~/.ssh/id_ed25519):
Enter passphrase (empty for no passphrase):
Your identification has been saved in ~/.ssh/id_ed25519
Your public key has been saved in ~/.ssh/id_ed25519.pub
Génère la paire. ed25519 est le type recommandé aujourd'hui (court, rapide, sûr) ; -t rsa -b 4096 reste un fallback pour les vieux serveurs. La passphrase chiffre la clé privée au repos — vivement conseillée, couplée à ssh-agent pour ne la saisir qu'une fois par session.
$ ssh-copy-id -i ~/.ssh/id_ed25519.pub deploy@web
Copie explicitement la clé publique Ed25519. Une authentification initiale est nécessaire. Les connexions suivantes peuvent encore demander la passphrase de la clé, une confirmation ou un second facteur selon la configuration. Ne copier que la clé .pub ; ssh-copy-id gère normalement le dossier et ses permissions.
$ eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
ssh-agent garde la clé déverrouillée en mémoire : on saisit la passphrase une fois pour toute la session. ssh-add -l liste les clés chargées.
Permissions strictes : SSH refuse d'utiliser des clés ou un dossier ~/.ssh trop ouverts. La recette : chmod 700 ~/.ssh, chmod 600 sur la clé privée et authorized_keys, 644 sur la clé .pub. Côté serveur, la clé privée ne voyage JAMAIS — seule la .pub est déposée.

Voir aussi : ssh scp chmod

ssh-agent · ssh-add

Garder une clé SSH déverrouillée le temps d'une session

Une clé privée protégée par une phrase de passe demande cette phrase à chaque connexion. ssh-agent garde la clé déverrouillée en mémoire, et ssh-add la lui confie : la phrase n'est demandée qu'une fois. Les bureaux graphiques lancent en général un agent automatiquement.

Options de ssh-add

ssh-add [CLÉ]Ajoute une clé à l'agent (les clés par défaut de ~/.ssh sans argument).
-lListe les empreintes des clés chargées.
-t DURÉERetire la clé automatiquement après ce délai, par exemple -t 1h.
-d CLÉ / -DRetire une clé, ou toutes les clés.
$ eval "$(ssh-agent -s)"
ssh-add -t 4h ~/.ssh/id_ed25519
Démarre un agent dans le shell courant, puis lui confie la clé pour quatre heures. Les connexions suivantes ne redemandent plus la phrase de passe.
$ ssh-add -l
256 SHA256:7Lr0yZ1kqS4bT9wXc2hVfE8nM3pJ5uA6dG0oR1sK2zQ alice@poste (ED25519)
Vérifie quelles clés sont chargées. The agent has no identities. signifie qu'aucune ne l'est.
Transfert d'agent : ssh -A rend l'agent utilisable depuis le serveur distant. Un administrateur de ce serveur pourrait alors s'en servir pour se connecter ailleurs avec les clés de l'utilisateur. Le réserver aux machines de confiance, ou préférer ssh -J pour rebondir.

Voir aussi : ssh ssh-keygen git

TLS et certificats

Vérifier ce qu'un serveur chiffré présente réellement : certificat, émetteur, noms couverts et dates de validité.

openssl

Inspecter des certificats et tester une connexion TLS

openssl est la boîte à outils de référence pour TLS : ouvrir une connexion chiffrée vers un serveur, lire un certificat (émetteur, noms couverts, dates de validité), générer des clés et des certificats de test. C'est le moyen le plus direct de vérifier ce qu'un serveur HTTPS présente réellement.

Sous-commandes principales

s_client -connect HÔTE:PORTOuvre une connexion TLS et affiche la chaîne de certificats et la négociation.
x509 -in FICHIER -noout -textAffiche un certificat en clair.
x509 -noout -datesAffiche seulement les dates de début et de fin de validité.
req -x509 -newkey ...Génère une clé et un certificat autosigné.
rand -base64 NProduit N octets aléatoires encodés en base64, par exemple pour un mot de passe ou un secret.
$ openssl s_client -connect exemple.fr:443 -servername exemple.fr < /dev/null 2> /dev/null | openssl x509 -noout -subject -issuer -dates
subject=CN=exemple.fr
issuer=C=US, O=Let's Encrypt, CN=R11
notBefore=Sep 12 08:14:05 2026 GMT
notAfter=Dec 11 08:14:04 2026 GMT
Récupère le certificat présenté par le serveur et affiche pour qui il a été émis, par qui, et jusqu'à quand il est valide. Le < /dev/null ferme la connexion dès la négociation terminée.
$ openssl x509 -in /etc/ssl/certs/site.pem -noout -text | less
Lit un certificat local en détail : noms alternatifs (Subject Alternative Name), algorithme, extensions.
$ openssl req -x509 -newkey rsa:4096 -nodes -keyout cle.pem -out cert.pem -days 365 -subj "/CN=test.local"
Crée un certificat autosigné valable un an, pour un environnement de test. Les navigateurs le refuseront : pour un site public, utiliser une autorité comme Let's Encrypt.
$ openssl rand -base64 32
Génère un secret aléatoire de 32 octets.
Serveur qui héberge plusieurs sites : le serveur choisit le certificat d'après le nom envoyé par le client (SNI). Si -connect reçoit une adresse IP, aucun nom n'est envoyé : ajouter -servername avec le nom du site pour obtenir le bon certificat.

Voir aussi : curl ssh-keygen gpg

VPN

Relier des machines ou des réseaux à travers Internet par un tunnel chiffré : WireGuard, intégré au noyau et simple à configurer, ou OpenVPN, plus ancien et très répandu.

wg · wg-quick

Configurer et inspecter un tunnel WireGuard

WireGuard est un VPN intégré au noyau Linux, simple et rapide : chaque machine a une paire de clés, et chaque pair est déclaré par sa clé publique et les adresses qu'il peut utiliser. wg gère les clés et affiche l'état du tunnel ; wg-quick monte ou démonte une interface à partir d'un fichier /etc/wireguard/wg0.conf.

Syntaxe

# /etc/wireguard/wg0.conf — côté client, exemple à adapter
[Interface]
PrivateKey = <clé privée du client>
Address = 10.0.0.2/24

[Peer]
PublicKey = <clé publique du serveur>
Endpoint = 203.0.113.10:51820
AllowedIPs = 10.0.0.0/24
PersistentKeepalive = 25

Commandes principales

wg genkeyGénère une clé privée.
wg pubkeyCalcule la clé publique d'une clé privée lue sur l'entrée standard.
wg showÉtat des interfaces : pairs, dernière poignée de main, volumes échangés.
wg-quick up wg0Monte l'interface décrite par /etc/wireguard/wg0.conf.
wg-quick down wg0Démonte l'interface.
$ umask 077
wg genkey | tee privee.key | wg pubkey > publique.key
Crée une paire de clés. Le umask 077 empêche les autres utilisateurs de lire la clé privée. Seule la clé publique se transmet à l'autre extrémité.
# wg-quick up wg0
systemctl enable wg-quick@wg0
Monte le tunnel, puis l'active à chaque démarrage.
# wg show wg0 latest-handshakes
Affiche, pour chaque pair, l'heure de la dernière poignée de main. Si elle date de plus de deux ou trois minutes alors que du trafic devrait passer, la liaison est rompue : vérifier l'Endpoint, le port UDP et le pare-feu.
La clé privée ne quitte jamais la machine : wg show sans option n'affiche pas les clés privées, mais wg showconf et le fichier de configuration les contiennent. Ne jamais les copier dans un ticket, un dépôt ou une capture d'écran.

Voir aussi : openvpn ip nft

openvpn

Client et serveur VPN basés sur TLS

OpenVPN établit un tunnel chiffré par TLS, avec des certificats ou des identifiants. Plus ancien et plus lourd que WireGuard, il reste très répandu, notamment chez les fournisseurs VPN et en entreprise : on reçoit souvent un fichier .ovpn qui contient toute la configuration.

Options principales

--config FICHIERLance OpenVPN avec un fichier de configuration (.ovpn ou .conf).
--daemonPasse en arrière-plan après le démarrage.
--verb NNiveau de détail du journal, de 0 à 11 ; 3 est un bon réglage de diagnostic.
--auth-user-pass FICHIERLit l'identifiant et le mot de passe dans un fichier au lieu de les demander.
# openvpn --config client.ovpn
Monte le tunnel au premier plan : le journal s'affiche dans le terminal et Initialization Sequence Completed indique que la connexion est établie. Ctrl+C la coupe.
# cp client.ovpn /etc/openvpn/client/bureau.conf
systemctl enable --now openvpn-client@bureau
Installe la configuration comme service : le nom de l'unité reprend celui du fichier, sans .conf. Sur Debian et Ubuntu, la même approche s'applique avec les répertoires prévus par le paquet.
$ nmcli connection import type openvpn file client.ovpn
Sur un poste avec NetworkManager, importe le profil pour le gérer depuis l'interface graphique. Nécessite le module NetworkManager-openvpn.
Vérifier que le trafic passe par le tunnel : ip route doit montrer les routes vers l'interface tun0, et curl -s https://ifconfig.me afficher l'adresse publique du VPN si tout le trafic est redirigé.

Voir aussi : wg nmcli openssl

Pare-feu

Filtrer ce qui entre et sort de la machine. Dans le noyau, le filtrage repose sur netfilter ; ufw (Debian/Ubuntu) et firewall-cmd (Fedora/RHEL) sont des interfaces qui y écrivent leurs règles via nftables, ou iptables sur les systèmes plus anciens. fail2ban s'appuie sur ce pare-feu pour bannir automatiquement les adresses qui multiplient les échecs.

ufw

Pare-feu simple pour Ubuntu/Debian (Uncomplicated FireWall)

ufw est un wrapper haut-niveau autour de iptables/nftables, conçu pour être lisible par un humain. Idéal pour les serveurs simples ou les desktops Ubuntu. Désactivé par défaut sur la plupart des installations — il faut explicitement ufw enable.

Commandes principales

ufw status [verbose]Liste les règles actives. verbose ajoute les politiques par défaut.
ufw enable / disableActive ou désactive le pare-feu (persistant).
ufw allow PORT[/proto]Autorise un port (22/tcp) ou un service nommé (ssh).
ufw deny PORTRefuse explicitement (par défaut, ce qui n'est pas autorisé est déjà refusé).
ufw delete NSupprime la règle numéro N (visible avec ufw status numbered).
ufw default deny incomingPolitique par défaut pour le trafic entrant. Pendant allow outgoing pour le sortant.
# ufw default deny incoming
ufw default allow outgoing
ufw allow ssh
ufw allow 80,443/tcp
ufw enable
Recette pour un serveur utilisant SSH sur 22/tcp. Si le port SSH a été personnalisé, autoriser son port réel avant ufw enable ; le nom ssh vient de /etc/services et ne lit pas sshd_config. Vérifier aussi l'accès IPv6 et garder un moyen de récupération lors d'une modification distante.
$ ufw status numbered
Status: active

     To                         Action      From
     --                         ------      ----
[ 1] 22/tcp                     ALLOW IN    Anywhere
[ 2] 80,443/tcp                 ALLOW IN    Anywhere
[ 3] 22/tcp (v6)                ALLOW IN    Anywhere (v6)
Vue numérotée pour pouvoir supprimer une règle précise. (v6) indique les règles IPv6 — ufw les crée automatiquement quand on ne précise pas de source.
# ufw allow from 192.168.1.0/24 to any port 5432 proto tcp
Règle plus fine : autoriser PostgreSQL uniquement depuis le LAN. La syntaxe générale est from SRC to DST port P proto P — chaque partie est optionnelle.
Limites : ufw n'expose qu'une fraction de la puissance de netfilter. Pour des règles complexes (NAT, marquage, forwarding entre interfaces), il faut soit éditer /etc/ufw/before.rules à la main, soit passer directement à nftables.

Voir aussi : nftables ss

firewall-cmd

Pare-feu par zones de Fedora, RHEL et dérivées (firewalld)

firewalld est le pare-feu par défaut des distros Red Hat. Sa particularité : organiser les règles par zones (public, trusted, dmz…). Chaque interface est rattachée à une zone, et les règles s'appliquent à la zone, pas à l'interface directement. Modèle plus modulaire qu'ufw quand on a plusieurs réseaux.

Commandes principales

--stateService actif ou non.
--get-active-zonesListe les zones avec interfaces rattachées.
--list-all [--zone=Z]Toutes les règles de la zone (par défaut la zone par défaut).
--add-service=NAMEAutorise un service (HTTP, SSH…). Liste : --get-services.
--add-port=PORT/PROTOAutorise un port arbitraire.
--permanentPersiste sur disque. Sans ce flag, la règle disparaît au reload. Suivre d'un --reload pour appliquer.
# firewall-cmd --permanent --add-service=http
firewall-cmd --permanent --add-service=https
firewall-cmd --permanent --add-port=8080/tcp
firewall-cmd --reload
Recette d'ouverture pour un serveur web qui écoute aussi sur 8080. --permanent écrit dans /etc/firewalld/zones/ mais n'applique pas tout de suite — d'où le --reload final. Variante : exécuter sans --permanent pour tester puis avec --permanent pour persister.
$ firewall-cmd --list-all
public (active)
  target: default
  interfaces: eth0
  sources:
  services: dhcpv6-client ssh http https
  ports: 8080/tcp
  masquerade: no
  forward-ports:
  rich rules:
Vue d'ensemble d'une zone : services autorisés (ssh http https), ports manuels (8080/tcp), interfaces rattachées (eth0). Le (active) indique que la zone a au moins une interface ou un default.
# firewall-cmd --change-interface=eth1 --zone=internal --permanent
Enregistre l'interface eth1 dans la zone internal de la configuration permanente. --permanent seul ne change pas nécessairement l'état courant : appliquer ensuite avec --reload, ou modifier séparément le runtime. Avec NetworkManager, définir aussi la zone dans le profil de connexion pour éviter une réaffectation ultérieure.
Rich rules : pour des conditions complexes (limite de débit, source spécifique, log), firewalld a un mini-DSL appelé rich rules. Exemple : firewall-cmd --add-rich-rule='rule family=ipv4 source address=10.0.0.0/8 service name=ssh log prefix="SSH-LAN " accept'. Moins lisible mais évite de descendre à nftables.

Voir aussi : ufw nftables systemctl

nft · iptables

Backend de pare-feu du noyau (nftables, et son ancêtre iptables)

nftables (commande nft) est le système de pare-feu intégré au noyau Linux depuis 3.13 (2014). Il remplace progressivement iptables, son prédécesseur — sur les distros modernes, iptables est en fait un wrapper iptables-nft qui traduit en règles nftables. Le langage nft est plus expressif, supporte IPv4 et IPv6 dans la même règle, et s'écrit dans un fichier de config plutôt qu'en commandes shell empilées.

Syntaxe

# Lister les regles actives
nft list ruleset
nft list table inet filter

# Ajouter une regle ponctuelle
nft add rule inet filter input tcp dport 22 accept

# Charger un fichier de config
nft -f /etc/nftables.conf
$ nft list ruleset | head -20
Vue de l'état complet du pare-feu noyau. nft list ruleset dump tout — tables, chaînes, règles, en syntaxe rechargeable. Pour sauvegarder l'état avant de bidouiller : nft list ruleset > /tmp/backup-nft.conf.

Syntaxe

# /etc/nftables.conf — pare-feu type pour serveur web
flush ruleset

table inet filter {
    chain input {
        type filter hook input priority filter; policy drop;

        iif lo accept
        ct state established,related accept
        ct state invalid drop

        tcp dport { 22, 80, 443 } accept
        icmp type echo-request limit rate 5/second accept
        icmpv6 type { destination-unreachable, packet-too-big, time-exceeded, parameter-problem, nd-neighbor-solicit, nd-neighbor-advert, nd-router-solicit, nd-router-advert } accept
        icmpv6 type echo-request limit rate 5/second accept
    }
    chain forward { type filter hook forward priority filter; policy drop; }
    chain output  { type filter hook output  priority filter; policy accept; }
}
Fichier à adapter, pas une commande à coller : flush ruleset efface aussi les règles nftables d'autres outils ; ne l'utiliser que si ce fichier est propriétaire de tout le pare-feu. Adapter le port SSH et les services avant chargement, prévoir un accès de secours et vérifier la configuration avec nft -c -f FICHIER. Les règles autorisent les connexions suivies, certains messages ICMP et les ports déclarés ; les besoins DHCP, routage et conteneurs peuvent imposer d'autres règles.
# nft -f /etc/nftables.conf
systemctl enable --now nftables
Charge immédiatement ce fichier puis active nftables.service. La persistance dépend du service fourni par la distribution : /etc/nftables.conf est courant sur Debian, tandis que Fedora utilise notamment /etc/sysconfig/nftables.conf et des fichiers inclus. Vérifier systemctl cat nftables.service et la configuration réellement chargée ; ne pas faire gérer les mêmes règles en parallèle par firewalld ou ufw.
$ iptables-translate -A INPUT -p tcp --dport 22 -j ACCEPT
nft 'add rule ip filter INPUT tcp dport 22 counter accept'
Outil de migration : convertit une commande iptables en son équivalent nft. Utile quand on hérite d'un vieux script iptables et qu'on veut le porter sans tout réécrire à la main.
Coexistence iptables/nftables : iptables-legacy et nftables peuvent techniquement coexister, mais leurs règles sont distinctes et peuvent toutes agir sur le trafic. iptables-nft utilise au contraire le backend nftables. Identifier le backend et le gestionnaire propriétaire des règles avant de modifier : éviter de mélanger une gestion manuelle avec firewalld, ufw ou les règles de conteneurs. Un flush ruleset efface toutes les règles nftables, y compris celles d'autres outils.

Voir aussi : ufw firewall-cmd ss

fail2ban-client

Consulter et piloter les bannissements de fail2ban

fail2ban surveille les journaux et bannit, via le pare-feu, les adresses qui accumulent les échecs : mots de passe SSH erronés, erreurs d'authentification web, etc. Chaque règle de surveillance s'appelle une prison (jail). fail2ban-client interroge et pilote le service en cours d'exécution.

Sous-commandes principales

statusListe les prisons actives.
status PRISONDétail d'une prison : échecs comptés et adresses bannies.
set PRISON banip IPBannit manuellement une adresse.
set PRISON unbanip IPLève le bannissement d'une adresse.
reloadRelit la configuration sans arrêter le service.
# fail2ban-client status sshd
Status for the jail: sshd
|- Filter
|  |- Currently failed: 3
|  |- Total failed:     412
|  `- Journal matches:  _SYSTEMD_UNIT=sshd.service + _COMM=sshd
`- Actions
   |- Currently banned: 2
   |- Total banned:     57
   `- Banned IP list:   203.0.113.42 198.51.100.7
Montre combien d'adresses sont bannies en ce moment et lesquelles.
# fail2ban-client set sshd unbanip 203.0.113.42
Débannit une adresse, par exemple un collègue qui s'est trompé de mot de passe plusieurs fois.
# fail2ban-regex /var/log/nginx/error.log /etc/fail2ban/filter.d/nginx-http-auth.conf
Teste un filtre sur un journal réel avant de l'activer : la sortie indique combien de lignes correspondent.
Ne pas modifier jail.conf : ce fichier est remplacé lors des mises à jour. Écrire la configuration locale dans /etc/fail2ban/jail.local ou dans /etc/fail2ban/jail.d/*.local.

Voir aussi : firewall-cmd nft journalctl

Scan et identification

Découvrir ce qui est ouvert sur un réseau ou un hôte.

nmap

Scanner de ports et de services

L'outil de référence pour découvrir les hôtes actifs d'un réseau, lister leurs ports ouverts et identifier les services qui y répondent. Ses scripts (NSE) vont plus loin : certificats TLS, algorithmes SSH, titres de pages web. Très puissant — à utiliser uniquement sur des réseaux dont on a la responsabilité.

Types de scan

-snPing scan : ne scanne aucun port, détecte seulement les hôtes actifs.
-sTScan par connexion TCP complète. C'est le scan par défaut sans droits root.
-sSScan SYN, plus rapide et plus discret : la connexion n'est jamais terminée. Scan par défaut en root.
-sUScan UDP (DNS, NTP, SNMP…). Nécessite root et reste lent.
-PnConsidère l'hôte comme actif sans le pinger : utile quand il ne répond pas au ping.

Ports, détection et sortie

-p PORTSPorts à scanner (ex. -p 22,80,443 ou -p 1-1000) ; -p- pour les 65 535 ports.
--top-ports NLes N ports les plus courants. Sans option, nmap en scanne 1 000.
--openN'affiche que les ports ouverts.
-sVDétecte les services et leur version.
-ODétecte le système d'exploitation. Nécessite root.
-sC / --script NOMLance les scripts NSE par défaut, ou un script précis.
-AMode agressif : versions, système, scripts par défaut et traceroute.
-T4Profil de temporisation plus rapide, adapté à un réseau local fiable (de -T0 à -T5).
-nAucune résolution DNS : scan plus rapide.
-oA BASEEnregistre le résultat dans trois formats : normal, XML et « grepable ».
$ nmap -sn 192.168.1.0/24
Liste les machines actives sur le réseau local.
$ nmap -sV -p 22,80,443 monserveur.local
PORT    STATE SERVICE  VERSION
22/tcp  open  ssh      OpenSSH 9.9 (protocol 2.0)
80/tcp  open  http     nginx 1.26.3
443/tcp open  ssl/http nginx 1.26.3
Quels services tournent et dans quelle version : utile pour repérer un logiciel à mettre à jour.
# nmap -sS -p- --open -T4 192.168.1.10
Vérifie tous les ports TCP d'une machine et n'affiche que ceux qui sont ouverts. Un port inattendu signale souvent un service oublié ou mal limité.
# nmap -sU -p 53,123,161 192.168.1.1
Contrôle les services UDP courants d'un routeur : DNS, NTP et SNMP. Un port UDP sans réponse est affiché open|filtered, car nmap ne peut pas trancher.
$ nmap -Pn -p 443 --script ssl-cert,ssl-enum-ciphers monserveur.local
Affiche le certificat présenté et les suites de chiffrement acceptées, avec une note de A à F. Pratique pour vérifier une configuration TLS après un changement.
$ nmap -p 22 --script ssh2-enum-algos monserveur.local
Liste les algorithmes proposés par le serveur SSH, pour repérer des algorithmes obsolètes à désactiver.
$ nmap -sV --top-ports 100 -oA scan-lan 192.168.1.0/24
Inventaire rapide d'un réseau, enregistré dans scan-lan.nmap, scan-lan.xml et scan-lan.gnmap. Garder ces fichiers permet de comparer deux scans et de voir ce qui a changé.
Avec ou sans root : sans droits root, nmap se limite au scan par connexion TCP (-sT) et ne peut ni scanner l'UDP ni détecter le système. Le pare-feu de la cible influence aussi le résultat : un port filtered ne répond pas, ce qui ne dit pas s'il est ouvert ou fermé.
Aspect légal : scanner un système qui ne vous appartient pas peut être considéré comme une intrusion dans plusieurs juridictions. À réserver à votre propre infrastructure ou avec autorisation explicite.

Voir aussi : ss nc tcpdump