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 préférez désormais ip et ss.

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
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 avec hostnamectl : 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.

Interfaces réseau

Configurer et inspecter les cartes réseau, leurs adresses 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.

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 : apprenez plutôt ip a et ip r, vous tomberez sur ifconfig de moins en moins souvent.

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

Diagnostic

Vérifier qu'une machine est joignable et par quel chemin.

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.

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.

DNS

Résoudre un nom en IP (et inversement), inspecter les enregistrements.

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.

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

host

Résolution DNS, version concise

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

Ports et connexions

Voir qui écoute, qui est connecté, et sur quel port.

ss

Inspecter les sockets (remplaçant moderne de netstat)

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.

netstat

Outil legacy, équivalent de ss

$ netstat -tulnp

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

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

HTTP et téléchargement

Faire des requêtes HTTP en ligne de commande.

curl

Couteau suisse des requêtes HTTP/HTTPS/FTP

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.

wget

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

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

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

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

Pare-feu

Filtrer ce qui entre et sort de la machine. Trois interfaces courantes — ufw côté Debian/Ubuntu, firewall-cmd côté Fedora/RHEL, nftables comme backend kernel moderne sous-jacent. Le noyau Linux a toujours un seul système de pare-feu actif ; ufw et firewalld ne sont que des frontends qui écrivent des règles dans nftables (ou iptables sur les vieux noyaux).

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 zones-based pour Fedora/RHEL/CentOS (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.
# # /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; }
}
Exemple de fichier à adapter, pas une commande shell à 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

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 des hôtes vivants et identifier les services ouverts. Très puissant — à utiliser uniquement sur des réseaux dont vous avez la responsabilité.

Options

-snPing scan : ne scanne pas les ports, juste détecte les hôtes vivants.
-sVDétecte les versions des services.
-p PORTSPorts à scanner (ex. -p 22,80,443 ou -p 1-1000).
-AMode agressif : versions, OS, scripts.
-ODétection du système d'exploitation.
$ nmap -sn 192.168.1.0/24
Liste les machines actives sur le réseau local.
$ nmap -sV -p 22,80,443 monserveur.local
Quels services tournent et dans quelle version.
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.