Pare-feu cloud : protéger une VM, démonstration

Un service lancé pour un test, un panneau d'administration resté sur son port par défaut, une base de données qui écoute sur toutes les interfaces : sur une machine exposée à Internet, ce sont rarement les services voulus qui posent problème, ce sont les autres. Un pare-feu ferme d'office tout ce qu'on n'a pas décidé d'ouvrir.

Le pare-feu FFxF se gère depuis la console, sans rien installer dans la machine. Il protège de la même façon Linux, Windows ou BSD, et une erreur de configuration dans le système ne peut pas le désactiver. Ce guide le pose sur une vraie machine, du constat de départ jusqu'aux règles de sortie, avec les sorties obtenues à chaque étape.

1. Ce que voit Internet

La machine de démonstration fait tourner SSH, et un petit service HTTP sur le port 8080, lancé pour un essai et oublié. Côté système, les deux écoutent sur toutes les adresses :

$ ss -ltn
LISTEN  0  128   0.0.0.0:22     0.0.0.0:*
LISTEN  0  5     0.0.0.0:8080   0.0.0.0:*
LISTEN  0  128      [::]:22        [::]:*

Depuis une autre machine, n'importe où sur Internet, les deux ports répondent, et la page interne s'affiche :

$ for p in 22 8080; do timeout 5 bash -c "</dev/tcp/23.159.52.19/$p" && echo "$p ouvert"; done
22 ouvert
8080 ouvert
$ curl http://23.159.52.19:8080/
admin interne

Sans pare-feu, une machine FFxF accepte tout le trafic entrant : c'est le comportement attendu d'un serveur nu, et c'est à vous de choisir ce qui reste ouvert.

2. Créer le pare-feu

Dans la console, sous Pare-feux, créez un pare-feu nommé web. Il démarre avec SSH et le ping ouverts. Les raccourcis au-dessus du formulaire de règle remplissent le protocole et les ports d'un clic : Web ajoute TCP 80 et 443. La même chose par l'API :

curl -s -X POST https://api.ffxf.net/v1/firewalls \
     -H "Authorization: Bearer $FFXF_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "name": "web",
           "rules": [
             {"protocol": "tcp", "ports": "22", "description": "SSH"},
             {"protocol": "tcp", "ports": "80,443", "description": "Web"},
             {"protocol": "icmp", "description": "Ping"}
           ]
         }'

Un pare-feu est un jeu de règles réutilisable. Tant qu'il n'est rattaché à aucune machine, il ne filtre rien.

3. Le rattacher à la machine

Sur la page du pare-feu, choisissez la machine dans la liste et cliquez sur Rattacher. Par l'API, c'est un appel :

curl -s -X POST https://api.ffxf.net/v1/firewalls/3/members \
     -H "Authorization: Bearer $FFXF_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"vm": 150}'

{"data":{"vm":150,"hostname":"lb-test","status":"applied"}}

applied veut dire que les règles sont enregistrées. Elles prennent effet dans la dizaine de secondes qui suit. Dès qu'une machine a au moins un pare-feu, tout trafic entrant qu'aucune règle n'ouvre est refusé.

4. Vérifier depuis l'extérieur

$ for p in 22 8080; do timeout 5 bash -c "</dev/tcp/23.159.52.19/$p" && echo "$p ouvert" || echo "$p filtré"; done
22 ouvert
8080 filtré
$ curl -m 5 http://23.159.52.19:8080/
curl: (28) Connection timed out after 5002 milliseconds

Le port 8080 ne répond plus du tout : la connexion reste sans réponse, il n'y a pas de refus qui confirmerait qu'une machine existe derrière. SSH et le ping passent toujours. Le service oublié tourne encore dans la machine, il n'est simplement plus joignable d'Internet.

Trois choses ne sont jamais filtrées : les réponses aux connexions que la machine ouvre elle-même (mises à jour, téléchargements, appels d'API), ses réseaux privés, et la console web du panel, qui atteint la machine même si toutes les règles sont fermées.

5. Restreindre SSH à une adresse

Une règle peut n'accepter que certaines sources : une adresse, une plage, en IPv4 comme en IPv6. Pour n'ouvrir SSH qu'au bureau :

{"protocol": "tcp", "ports": "22", "sources": ["203.0.113.0/24", "2001:db8::/32"], "description": "SSH bureau"}

Gardez toujours un chemin d'entrée. Un pare-feu qui n'ouvre pas TCP 22 (ou 3389 sous Windows) coupe SSH sur toutes les machines qu'il protège. La console web reste là pour réparer, mais un script ou un agent qui travaille en SSH perd sa machine.

6. Les règles de sortie

Par défaut, tout peut sortir. Dès qu'un pare-feu de la machine porte une règle de sortie, seul ce que les règles de sortie ouvrent peut partir, plus le DNS vers les résolveurs FFxF et le réseau privé. Ajoutons une seule règle : HTTPS en sortie.

{"direction": "out", "protocol": "tcp", "ports": "443", "description": "HTTPS sortant"}

Depuis la machine, quelques secondes plus tard :

$ curl -s -o /dev/null -w "%{http_code}\n" https://deb.debian.org/
200
$ curl -m 6 http://deb.debian.org/
curl: (28) Connection timed out after 6002 milliseconds
$ getent hosts deb.debian.org
2a04:4e42:400::644 debian.map.fastlydns.net

Le HTTPS passe, le HTTP est bloqué, et la résolution de noms fonctionne toujours. La première règle de sortie ferme tout le reste : sur une machine qui installe ses paquets en HTTP, il faut ouvrir le port 80 aussi. Le port 25 reste fermé quelles que soient les règles.

7. Un pare-feu, plusieurs machines

Un même pare-feu se rattache à autant de machines que vous voulez, et une machine peut en porter jusqu'à cinq, dont les règles s'additionnent. Un pare-feu base (SSH depuis le bureau, ping) sur toutes les machines, plus un pare-feu web sur celles qui servent des pages : quand l'adresse du bureau change, une seule modification met à jour tout le parc.

Les pare-feux sont inclus, sans supplément. Dix par compte, cinquante règles par pare-feu et vingt sources par règle ; au-delà, la page Pare-feux propose de demander une augmentation en un clic.

8. Par un agent IA

Le serveur MCP FFxF expose les mêmes actions : create_firewall, update_firewall, attach_firewall et les autres. On peut demander à Claude Code ou à Codex « ferme tout sauf SSH et le web sur mes machines de production » ; la consigne du serveur leur demande de garder TCP 22 ouvert, pour ne pas perdre l'accès à la machine en cours de travail.

Checklist

• Lister ce qui écoute vraiment avec ss -ltn.
• Un pare-feu avec SSH (ou RDP) et seulement les ports de vos services.
• Rattaché, puis vérifié depuis une autre machine.
• SSH restreint à vos adresses quand c'est possible.
• Règles de sortie seulement si vous savez ce que la machine doit joindre.

Le pare-feu FFxF et celui du système se complètent : le premier tient même si la machine est mal configurée, le second filtre ce qui circule entre les services de la machine. Pour le second, voir sécuriser un VPS Ubuntu. La référence complète est dans la documentation des pare-feux.