1686 lines
77 KiB
Plaintext
1686 lines
77 KiB
Plaintext
Ignorer et passer au contenu
|
||
Historique de chat
|
||
|
||
Vous avez dit :
|
||
Comment forcer un serveur linux réel 10 à utiliser un proxy pour accéder à internet et couper l'accès en direct à internet
|
||
ChatGPT a dit :
|
||
|
||
Réflexion durant 15s
|
||
Je pars de l’hypothèse que vous parlez d’un serveur RHEL 10 (Red Hat Enterprise Linux 10). Voici une procédure pragmatique — avec commandes — pour forcer tout le trafic sortant à passer par un proxy et bloquer tout accès direct à Internet. Je donne plusieurs leviers (variables système, systemd, dnf, et firewall/nftables) + une option « proxy transparent » (Squid) si vous préférez intercepter automatiquement le trafic. Je cite les points techniques importants.
|
||
1) Principe recommandé
|
||
Configurer le proxy système / applications (http(s)_proxy, no_proxy, DNF) afin que la plupart des logiciels utilisent le proxy.
|
||
GoLinuxCloud
|
||
+1
|
||
Mettre en place une politique egress stricte dans le pare-feu (nftables / firewalld) qui n’autorise que les connexions vers l’adresse IP du proxy (et peu d’exceptions : DNS interne, NTP, management) et bloque le reste. Cela empêche le contournement même si une appli n’utilise pas la variable d’environnement.
|
||
Red Hat Docs
|
||
+1
|
||
(Optionnel) Déployer Squid en mode transparent + redirection des connexions HTTP vers Squid si vous voulez intercepter les clients qui ne configurent pas le proxy — note : le HTTPS ne peut pas être intercepté sans interception TLS (mitm) ou sans configuration explicite client.
|
||
Dominik Rys
|
||
+1
|
||
2) Configuration des variables proxy (système & applications)
|
||
Créez un fichier global pour shell logins (bash) et /etc/environment :
|
||
# /etc/profile.d/proxy.sh (tous shells interactifs/login)
|
||
export http_proxy="http://proxy.corp.local:3128"
|
||
export https_proxy="http://proxy.corp.local:3128"
|
||
export ftp_proxy="http://proxy.corp.local:3128"
|
||
export no_proxy="localhost,127.0.0.1,.corp.local"
|
||
export HTTP_PROXY="$http_proxy"
|
||
export HTTPS_PROXY="$https_proxy"
|
||
export NO_PROXY="$no_proxy"
|
||
Et pour programmes non interactifs (aussi utile) :
|
||
# /etc/environment
|
||
http_proxy="http://proxy.corp.local:3128"
|
||
https_proxy="http://proxy.corp.local:3128"
|
||
no_proxy="localhost,127.0.0.1,.corp.local"
|
||
DNF/YUM (pour les mises à jour) — éditez /etc/dnf/dnf.conf :
|
||
[main]
|
||
proxy=http://proxy.corp.local:3128
|
||
# proxy_username=...
|
||
# proxy_password=...
|
||
Ces méthodes sont standard pour RHEL/CentOS/Fedora ; beaucoup d’apps respectent ces variables mais pas toutes.
|
||
GoLinuxCloud
|
||
+1
|
||
3) Variables visibles par les services systemd (processus démarrés par systemd)
|
||
Les services systemd (daemons) ne lisent pas /etc/profile. Pour que les unités systemd héritent du proxy, ajoutez une configuration manager-wide :
|
||
Créez /etc/systemd/system.conf.d/10-default-env.conf :
|
||
|
||
[Manager]
|
||
DefaultEnvironment="HTTP_PROXY=http://proxy.corp.local:3128" "HTTPS_PROXY=http://proxy.corp.local:3128" "NO_PROXY=localhost,127.0.0.1,.corp.local"
|
||
Puis rechargez systemd et redémarrez les services concernés :
|
||
systemctl daemon-reload
|
||
# redémarrer les services qui doivent utiliser le proxy, p.ex.
|
||
systemctl restart dnf-metadata.service || true
|
||
Autre option pour un service précis : créer un drop-in systemctl edit monservice et ajouter Environment= ou EnvironmentFile=. (Docs systemd / DefaultEnvironment).
|
||
freedesktop.org
|
||
+1
|
||
4) Bloquer tout accès direct : nftables (exemple)
|
||
Principe : n’autoriser que la sortie vers l’IP du proxy (ici 10.0.0.5:3128) + DNS interne (p.ex. 10.0.0.10) + loopback ; ensuite DROP tout le reste sur OUTPUT (pour le serveur lui-même).
|
||
Exemple minimal — adaptez IPs/interfaces selon votre infra :
|
||
|
||
# sauvegardez la config existante avant
|
||
nft list ruleset > /root/nft-before
|
||
|
||
# exemple de ruleset
|
||
nft flush ruleset
|
||
|
||
nft add table inet filter
|
||
|
||
# chaîne output : contrôle des connexions sortantes depuis le serveur lui-même
|
||
nft add chain inet filter output { type filter hook output priority 0 \; policy accept \; }
|
||
|
||
# loopback and established
|
||
nft add rule inet filter output oif lo accept
|
||
nft add rule inet filter output ct state established,related accept
|
||
|
||
# allow DNS to internal resolver (udp + tcp 53)
|
||
nft add rule inet filter output ip daddr 10.0.0.10 udp dport 53 accept
|
||
nft add rule inet filter output ip daddr 10.0.0.10 tcp dport 53 accept
|
||
|
||
# allow only to proxy IP:3128 (HTTP) and 3129 (exemple) and to proxy for HTTPS CONNECT (si proxy le supporte)
|
||
nft add rule inet filter output ip daddr 10.0.0.5 tcp dport {3128,3129,443} accept
|
||
|
||
# allow NTP to internal NTP server si nécessaire
|
||
nft add rule inet filter output ip daddr 10.0.0.11 udp dport 123 accept
|
||
|
||
# log+drop everything else (tester d'abord en log puis drop)
|
||
nft add rule inet filter output meta nftrace set 1 # (optionnel)
|
||
nft add rule inet filter output counter log prefix "EGRESS-DROP: " drop
|
||
Points importants :
|
||
Testez en premier en remplaçant drop par accept ou en ajoutant log pour vérifier ce qui serait bloqué.
|
||
Ne vous lockez pas hors du serveur : gardez SSH management autorisé (p.ex. autorisez le port SSH vers l’IP de management) avant d’appliquer un DROP global.
|
||
Vous pouvez faire la variante avec firewalld/zones si vous préférez son abstraction.
|
||
Red Hat Docs
|
||
+1
|
||
5) Option « proxy transparent » (Squid + redirection)
|
||
Si vous voulez que tout le trafic HTTP provenant du serveur lui-même (ou d’autres machines) soit intercepté par Squid local :
|
||
Installez et configurez Squid en mode intercept (http_port 3128 intercept).
|
||
Dominik Rys
|
||
Redirigez le trafic HTTP (port 80) vers squid avec nftables (ou iptables). Exemple iptables nat PREROUTING / nft nat redirect — mais pour HTTPS ça ne marche pas sans interception TLS (mitm) : HTTPS doit être en proxy explicite ou avec interception TLS (certificat) ce qui a des implications légales/sécurité. Pour une interception « complète » de flux d’applications, il faut TPROXY (pour conserver IP source) ou un gateway NAT.
|
||
Stack Overflow
|
||
+1
|
||
Exemple simple (iptables-style) pour rediriger HTTP vers Squid local :
|
||
# iptables (legacy) example
|
||
iptables -t nat -A OUTPUT -p tcp --dport 80 -m owner ! --uid-owner proxyuser -j REDIRECT --to-port 3128
|
||
Remarque : sur RHEL 10 vous allez probablement utiliser nftables ; la logique est la même mais la syntaxe diffère. Voir docs nftables et exemples de redirection.
|
||
ArchWiki
|
||
+1
|
||
6) Vérifications et pièges courants
|
||
Certaines applis n’utilisent pas http(s)_proxy (ex : certains services Java, binaires custom, docker daemon) — il faudra configurer chaque service (unit systemd, options de l’application, variables d’environnement) ou empêcher leur trafic par le firewall.
|
||
Server Fault
|
||
+1
|
||
HTTPS : impossible d’intercepter proprement sans TLS MITM (certificat à déployer partout) ; sinon obliger le proxy en bloquant la sortie HTTPS sauf vers le proxy (approche recommandée).
|
||
DNS : si vous bloquez tout DNS externe, assurez-vous que le serveur utilise un résolveur interne ou que le proxy résolve à sa place.
|
||
Ne vous lockez pas hors : conservez une règle spécifique pour l’administration (SSH depuis IP de gestion) avant d’appliquer des DROP globaux.
|
||
Sauvegardez la configuration actuelle (nft list ruleset, copies des fichiers) avant tout changement.
|
||
7) Résumé concret (checklist d’implémentation rapide)
|
||
Déployer /etc/profile.d/proxy.sh et /etc/environment.
|
||
Configurer /etc/dnf/dnf.conf.
|
||
Créer /etc/systemd/system.conf.d/10-default-env.conf puis systemctl daemon-reload.
|
||
Tester que les applications majeures utilisent le proxy.
|
||
Mettre en place règles nftables qui n’autorisent que l’accès au proxy + DNS interne + management. Testez en log avant drop.
|
||
(Option) Déployer Squid en mode intercept + rules de redirection si vous souhaitez proxy transparent pour HTTP.
|
||
Si vous voulez, je peux :
|
||
Générer un playbook Ansible/script bash prêt à exécuter (avec vos IPs : IP proxy, IP DNS, IP management) ;
|
||
Ou écrire le fichier nft complet adapté à vos adresses réseau (fournissez IP proxy, IP DNS, interface de sortie, et IP de management/SSH).
|
||
Dites-moi simplement les IP/ports que vous utilisez (ou confirmez que proxy.corp.local:3128 et 10.0.0.10 illustratifs sont OK) et je vous fournis les fichiers/commandes prêts à coller.
|
||
Vous avez dit :
|
||
point 4 avec firewalld à la place de nftables
|
||
ChatGPT a dit :
|
||
Parfait — voici la version avec firewalld pour remplacer le point 4. L’idée reste la même : autoriser seulement le trafic sortant nécessaire (proxy, DNS interne, NTP, SSH de management) et bloquer tout le reste en sortie. Je fournis des commandes firewall-cmd (immédiates + permanentes) en mode direct (ajout de règles dans la table filter de sortie).
|
||
Remplacez les adresses/ports d’exemple par celles de votre infra :
|
||
PROXY_IP=10.0.0.5 et PROXY_PORT=3128
|
||
DNS_IP=10.0.0.10
|
||
NTP_IP=10.0.0.11
|
||
MGMT_IP=192.0.2.5 (IP depuis laquelle vous administrez le serveur via SSH)
|
||
Interface sortante : si besoin, remplacez eth0 par votre interface réelle.
|
||
1) Principe important — ne vous lockez pas hors !
|
||
Avant toute chose, autorisez l’accès SSH depuis votre IP de management et/ou conservez une console locale. Sinon vous pouvez vous couper l’accès. Exécutez la commande SSH-management en premier (commande --add-rich-rule ci-dessous).
|
||
2) Variables d’exemple (copiez/éditez)
|
||
PROXY_IP=10.0.0.5
|
||
PROXY_PORT=3128
|
||
DNS_IP=10.0.0.10
|
||
NTP_IP=10.0.0.11
|
||
MGMT_IP=192.0.2.5
|
||
OUT_IF=eth0
|
||
3) Étapes — commandes (immédiates + permanentes)
|
||
Exécutez chaque paire de commandes : d’abord la version non-permanente (sans --permanent) pour tester immédiatement, puis la version --permanent pour rendre persistants les changements. Enfin firewall-cmd --reload pour appliquer les règles permanentes (la plupart des --permanent nécessitent reload pour prendre effet).
|
||
3.1 Autoriser SSH d’administration (INPUT) — impératif avant DROP global
|
||
# immédiat
|
||
firewall-cmd --add-rich-rule="rule family='ipv4' source address='$MGMT_IP' service name='ssh' accept"
|
||
|
||
# permanent
|
||
firewall-cmd --permanent --add-rich-rule="rule family='ipv4' source address='$MGMT_IP' service name='ssh' accept"
|
||
Vérifiez que vous pouvez toujours vous reconnecter depuis MGMT_IP avant d'aller plus loin.
|
||
3.2 Autoriser loopback et connexions établies (OUTPUT)
|
||
# loopback accept (OUTPUT)
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 0 -o lo -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 0 -o lo -j ACCEPT
|
||
|
||
# allow established,related (OUTPUT)
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
3.3 Autoriser DNS vers résolveur interne (UDP+TCP 53)
|
||
# UDP 53
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 5 -p udp -d $DNS_IP --dport 53 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 5 -p udp -d $DNS_IP --dport 53 -j ACCEPT
|
||
|
||
# TCP 53 (pour réponses longues / fallback)
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 6 -p tcp -d $DNS_IP --dport 53 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 6 -p tcp -d $DNS_IP --dport 53 -j ACCEPT
|
||
3.4 Autoriser uniquement le proxy (HTTP/HTTPS via proxy) — bloquer tout le reste
|
||
Autorisez le trafic TCP vers l’IP/port du proxy (ex : 3128). Si le proxy nécessite aussi d’autres ports (3129, 8080, CONNECT/443 via le proxy), ajoutez-les.
|
||
# autoriser proxy (ex HTTP proxy)
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 10 -p tcp -d $PROXY_IP --dport $PROXY_PORT -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 10 -p tcp -d $PROXY_IP --dport $PROXY_PORT -j ACCEPT
|
||
|
||
# si vous utilisez proxy pour HTTPS (CONNECT), autorisez aussi 443 vers le proxy (optionnel)
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 11 -p tcp -d $PROXY_IP --dport 443 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 11 -p tcp -d $PROXY_IP --dport 443 -j ACCEPT
|
||
3.5 Autoriser NTP vers serveur interne (si nécessaire)
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 15 -p udp -d $NTP_IP --dport 123 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 15 -p udp -d $NTP_IP --dport 123 -j ACCEPT
|
||
3.6 Autoriser autres services internes nécessaires (ex : syslog, LDAP, etc.)
|
||
Ajoutez règles similaires si vous dépendez d’autres serveurs internes. Exemple pour syslog TCP/514 :
|
||
# exemple syslog
|
||
# firewall-cmd --direct --add-rule ipv4 filter OUTPUT <prio> -p tcp -d <SYSLOG_IP> --dport 514 -j ACCEPT
|
||
# firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT <prio> -p tcp -d <SYSLOG_IP> --dport 514 -j ACCEPT
|
||
3.7 Journaliser et DROPPER le reste (rule finale)
|
||
ATTENTION : ajoutez cette règle en dernier (priorité élevée) et testez avant. Elle va bloquer tout le trafic sortant non explicitement autorisé.
|
||
# log (facultatif, utile pour debug) - notez que log peut générer beaucoup d'entrées
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 90 -m limit --limit 2/min -j LOG --log-prefix "EGRESS-DROP: " --log-level 4
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 90 -m limit --limit 2/min -j LOG --log-prefix "EGRESS-DROP: " --log-level 4
|
||
|
||
# drop tout le reste
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 100 -j DROP
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 100 -j DROP
|
||
4) Vérifier l’état et recharger
|
||
Après avoir appliqué les règles immédiates, vérifiez la table OUTPUT directe :
|
||
# liste des règles directes en cours
|
||
firewall-cmd --direct --get-all-rules
|
||
|
||
# recharger les règles permanentes (après avoir ajouté --permanent)
|
||
firewall-cmd --reload
|
||
Testez depuis le serveur :
|
||
curl --verbose --proxy http://$PROXY_IP:$PROXY_PORT http://example.com → devrait fonctionner.
|
||
curl -v http://example.com (sans proxy) → devrait échouer (DROP).
|
||
dig @${DNS_IP} example.com → devrait réussir.
|
||
Vérifiez les logs si vous avez activé la règle LOG (journalctl -k ou /var/log/messages selon config).
|
||
5) Remarques et pièges courants
|
||
Les --direct rules injectent des règles directement dans la table filter (comportement équivalent à nftables ip rules). Elles sont puissantes mais demandent prudence.
|
||
Certaines applications (ex : conteneurs Docker, services rootless) peuvent créer leurs propres chaînes ; testez les cas d’usage spécifiques (Docker, systemd-services).
|
||
HTTPS ne peut pas être « intercepté » simplement : si une application ouvre directement une connexion TLS vers une IP externe (443) elle sera bloquée par la règle DROP sauf si elle passe par le proxy (CONNECT). Donc assurez-vous que toutes les applications critiques sont configurées pour utiliser le proxy.
|
||
Conservez toujours une règle SSH de management avant la règle DROP.
|
||
Pour déboguer, retirez temporairement la règle finale DROP ou modifiez-la en REJECT/ACCEPT pendant les tests.
|
||
6) Option alternative — utiliser une politique “egress” par zone
|
||
Si vous préférez éviter les --direct, vous pouvez configurer des rich rules ou créer une zone dédiée et placer l’interface dans cette zone, mais le contrôle granulaire des règles OUTPUT (sortant depuis la machine) est plus simple et sûr via --direct comme ci-dessous.
|
||
Si vous voulez, je peux :
|
||
vous fournir un petit script bash qui applique toutes ces commandes en remplaçant automatiquement les variables (prêt à exécuter),
|
||
ou convertir ces règles en playbook Ansible.
|
||
Dites-moi si vous voulez le script prêt à exécuter (je le génère tout de suite avec vos IPs réelles si vous me les donnez), ou si vous souhaitez que j’adapte les règles (p.ex. autoriser d’autres ports/protocoles).
|
||
Vous avez dit :
|
||
etit script bash qui applique toutes ces commandes en remplaçant automatiquement les variables (prêt à exécuter), proxy = 172.31.10.23
|
||
ChatGPT a dit :
|
||
Parfait — voici un script bash prêt à exécuter qui applique les règles firewalld --direct décrites plus haut, en utilisant proxy = 172.31.10.23 (port 3128 par défaut). Le script essaie d’auto-détecter l’IP de management (votre IP SSH) et le résolveur DNS à partir de /etc/resolv.conf, mais vous pouvez aussi surcharger toutes les variables en appelant le script avec DNS_IP=... MGMT_IP=... NTP_IP=... ./apply-egress-firewall.sh.
|
||
⚠️ AVERTISSEMENT IMPORTANT — Ce script modifie les règles de pare-feu de sortie et peut bloquer l’accès Internet direct. Il ajoute d’abord la règle SSH pour votre IP de management afin d’éviter de vous verrouiller dehors, puis applique le reste. Lisez le script et sauvegardez l’état actuel si besoin. Exécutez en root (sudo).
|
||
|
||
Copiez-collez dans un fichier (p.ex. apply-egress-firewall.sh), rendez-le exécutable (chmod +x apply-egress-firewall.sh) et lancez-le (sudo ./apply-egress-firewall.sh).
|
||
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# ---------- CONFIG DEFAULTS (modifiable via environment) ----------
|
||
PROXY_IP="${PROXY_IP:-172.31.10.23}"
|
||
PROXY_PORT="${PROXY_PORT:-3128}"
|
||
|
||
# auto-detect DNS from /etc/resolv.conf (first nameserver) if not set
|
||
if [ -z "${DNS_IP-}" ]; then
|
||
DNS_IP=$(awk '/^nameserver/ {print $2; exit}' /etc/resolv.conf || true)
|
||
DNS_IP="${DNS_IP:-127.0.0.1}"
|
||
fi
|
||
|
||
# auto-detect management IP from SSH_CLIENT if available, else from who -m
|
||
if [ -z "${MGMT_IP-}" ]; then
|
||
if [ -n "${SSH_CLIENT-}" ]; then
|
||
MGMT_IP=$(awk '{print $1}' <<<"$SSH_CLIENT")
|
||
else
|
||
# who -m prints like "username pts/0 2025-09-16 12:00 (1.2.3.4)"
|
||
MGMT_IP=$(who -m | awk -F'[()]' '{print $2}' | awk '{print $1}')
|
||
fi
|
||
# fallback to localhost (safe but not useful remotely)
|
||
MGMT_IP="${MGMT_IP:-127.0.0.1}"
|
||
fi
|
||
|
||
# NTP default (modifiable)
|
||
NTP_IP="${NTP_IP:-pool.ntp.org}"
|
||
|
||
# interface optional (not used directly by --direct rules)
|
||
OUT_IF="${OUT_IF:-eth0}"
|
||
|
||
# Logging rule toggle
|
||
ENABLE_LOG="${ENABLE_LOG:-yes}" # set to "no" to disable log rule
|
||
|
||
# ------------------------------------------------------------------
|
||
echo "Résumé des variables (vous pouvez surcharger en exportant la variable avant exécution):"
|
||
echo " PROXY_IP = $PROXY_IP"
|
||
echo " PROXY_PORT = $PROXY_PORT"
|
||
echo " DNS_IP = $DNS_IP"
|
||
echo " NTP_IP = $NTP_IP"
|
||
echo " MGMT_IP = $MGMT_IP"
|
||
echo " OUT_IF = $OUT_IF"
|
||
echo " ENABLE_LOG = $ENABLE_LOG"
|
||
echo
|
||
echo "Cette opération va :"
|
||
echo " - sauvegarder l'état direct actuel de firewalld dans /root/firewalld-direct-before-*.txt"
|
||
echo " - ajouter des règles direct dans la table filter/OUTPUT pour n'autoriser que :"
|
||
echo " - loopback, established"
|
||
echo " - DNS vers $DNS_IP (udp/tcp 53)"
|
||
echo " - accès au proxy $PROXY_IP:$PROXY_PORT (et 443 vers le proxy pour CONNECT)"
|
||
echo " - NTP vers $NTP_IP (udp 123)"
|
||
echo " - SSH depuis $MGMT_IP (INPUT, pour ne pas vous lock-out)"
|
||
echo " puis ajouter une règle finale DROP pour OUTPUT."
|
||
echo
|
||
read -r -p "Si vous êtes certain, appuyez sur ENTER pour continuer (Ctrl-C pour annuler)..."
|
||
|
||
# must be root
|
||
if [ "$(id -u)" -ne 0 ]; then
|
||
echo "ERREUR: lancez ce script en root (sudo)." >&2
|
||
exit 2
|
||
fi
|
||
|
||
# Backup existing direct rules
|
||
TS=$(date +%Y%m%d-%H%M%S)
|
||
BACKUP="/root/firewalld-direct-before-${TS}.txt"
|
||
echo "Sauvegarde des règles direct existantes -> $BACKUP"
|
||
firewall-cmd --direct --get-all-rules >"$BACKUP" || true
|
||
|
||
# 1) Ensure SSH from MGMT_IP allowed (INPUT) immediate + permanent
|
||
echo "Ajout règle SSH (INPUT) pour $MGMT_IP"
|
||
firewall-cmd --add-rich-rule="rule family='ipv4' source address='$MGMT_IP' service name='ssh' accept"
|
||
firewall-cmd --permanent --add-rich-rule="rule family='ipv4' source address='$MGMT_IP' service name='ssh' accept"
|
||
|
||
# 2) Loopback accept (OUTPUT)
|
||
echo "Autoriser loopback (OUTPUT)"
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 0 -o lo -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 0 -o lo -j ACCEPT
|
||
|
||
# 3) established,related (OUTPUT)
|
||
echo "Autoriser connexions established/related (OUTPUT)"
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
|
||
# 4) DNS to DNS_IP UDP 53 + TCP 53
|
||
echo "Autoriser DNS vers $DNS_IP (udp/tcp 53)"
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 5 -p udp -d "$DNS_IP" --dport 53 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 5 -p udp -d "$DNS_IP" --dport 53 -j ACCEPT
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 6 -p tcp -d "$DNS_IP" --dport 53 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 6 -p tcp -d "$DNS_IP" --dport 53 -j ACCEPT
|
||
|
||
# 5) Allow proxy (TCP PROXY_PORT) and optionally 443 to proxy (for CONNECT)
|
||
echo "Autoriser trafic vers proxy $PROXY_IP:$PROXY_PORT et 443->proxy (CONNECT)"
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 10 -p tcp -d "$PROXY_IP" --dport "$PROXY_PORT" -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 10 -p tcp -d "$PROXY_IP" --dport "$PROXY_PORT" -j ACCEPT
|
||
|
||
# allow 443 to proxy to permit CONNECT-through-proxy if desired
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 11 -p tcp -d "$PROXY_IP" --dport 443 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 11 -p tcp -d "$PROXY_IP" --dport 443 -j ACCEPT
|
||
|
||
# 6) NTP to NTP_IP (udp 123)
|
||
echo "Autoriser NTP vers $NTP_IP (udp 123)"
|
||
# If NTP_IP is a hostname (pool.ntp.org), allow UDP/TCP to port 123 to anywhere (or leave to DNS resolution)
|
||
if [[ "$NTP_IP" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 15 -p udp -d "$NTP_IP" --dport 123 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 15 -p udp -d "$NTP_IP" --dport 123 -j ACCEPT
|
||
else
|
||
echo "NTP_IP n'est pas une IP (valeur: $NTP_IP). Ajout d'une règle permissive pour NTP (udp port 123 vers ANY)."
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 15 -p udp --dport 123 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 15 -p udp --dport 123 -j ACCEPT
|
||
fi
|
||
|
||
# 7) (Option) autres services internes utiles — place holder
|
||
# echo "Ajoutez ici d'autres règles si besoin (syslog, LDAP, etc.)"
|
||
|
||
# 8) LOG rule (optionnel)
|
||
if [ "${ENABLE_LOG,,}" = "yes" ]; then
|
||
echo "Ajout règle LOG (limited) pour OUTPUT (priorité 90)"
|
||
# log limit 2/min — ajustez selon vos besoins
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 90 -m limit --limit 2/min -j LOG --log-prefix "EGRESS-DROP: " --log-level 4
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 90 -m limit --limit 2/min -j LOG --log-prefix "EGRESS-DROP: " --log-level 4
|
||
fi
|
||
|
||
# 9) DROP final (OUTPUT)
|
||
echo "Ajout règle DROP finale (OUTPUT)"
|
||
firewall-cmd --direct --add-rule ipv4 filter OUTPUT 100 -j DROP
|
||
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 100 -j DROP
|
||
|
||
# 10) show direct rules and reload permanent config
|
||
echo
|
||
echo "Règles direct en cours :"
|
||
firewall-cmd --direct --get-all-rules
|
||
|
||
echo
|
||
echo "Reload des règles permanentes (firewall-cmd --reload)"
|
||
firewall-cmd --reload
|
||
|
||
echo
|
||
echo "TESTS SUGGÉRÉS :"
|
||
echo " - curl -v --proxy http://$PROXY_IP:$PROXY_PORT http://example.com # doit fonctionner"
|
||
echo " - curl -v http://example.com # doit échouer (DROP)"
|
||
echo " - dig @$DNS_IP example.com # doit résoudre"
|
||
echo
|
||
echo "Si besoin de revenir en arrière :"
|
||
echo " - restaurez les règles direct à partir de $BACKUP (ou redémarrez firewalld et ajustez manuellement)"
|
||
echo
|
||
echo "Script terminé."
|
||
Si vous voulez, je peux :
|
||
adapter le script pour autoriser d’autres ports (ex. 8080, 8443) ;
|
||
produire une version Ansible équivalente ;
|
||
ou générer une version qui redirige HTTP local vers un Squid local (proxy transparent) plutôt que d’autoriser uniquement un proxy distant.
|
||
Laquelle préférez-vous ?
|
||
Vous avez dit :
|
||
Autoriser loopback (OUTPUT)
|
||
Error: INVALID_IPV: 'ipv4' is not a valid backend or is unavailable
|
||
ChatGPT a dit :
|
||
Ah, je vois le souci 👍
|
||
Sur RHEL / Rocky / Alma (firewalld >= 1.0), il n’y a plus d’option ipv4/ipv6 dans --direct. Il faut utiliser simplement inet comme family (ou rien du tout si vous voulez que ça s’applique partout). La syntaxe firewall-cmd --direct --add-rule ipv4 ... est rejetée sur les versions récentes, d’où votre erreur INVALID_IPV.
|
||
|
||
👉 Correction : remplacez ipv4 par inet. Exemple pour la règle loopback :
|
||
|
||
# correct
|
||
firewall-cmd --direct --add-rule inet filter OUTPUT 0 -o lo -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule inet filter OUTPUT 0 -o lo -j ACCEPT
|
||
Idem pour toutes les autres lignes du script.
|
||
Donc :
|
||
--direct --add-rule ipv4 filter ... ⛔
|
||
--direct --add-rule inet filter ... ✅
|
||
Exemple corrigé pour quelques règles principales :
|
||
# connexions established/related
|
||
firewall-cmd --direct --add-rule inet filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule inet filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
|
||
# DNS
|
||
firewall-cmd --direct --add-rule inet filter OUTPUT 5 -p udp -d $DNS_IP --dport 53 -j ACCEPT
|
||
firewall-cmd --direct --add-rule inet filter OUTPUT 6 -p tcp -d $DNS_IP --dport 53 -j ACCEPT
|
||
|
||
# proxy
|
||
firewall-cmd --direct --add-rule inet filter OUTPUT 10 -p tcp -d $PROXY_IP --dport $PROXY_PORT -j ACCEPT
|
||
Astuce pour tester sans vous enfermer :
|
||
Appliquez d’abord les règles sans le DROP final.
|
||
Vérifiez que vous pouvez encore passer par le proxy.
|
||
Ajoutez ensuite la règle DROP :
|
||
firewall-cmd --direct --add-rule inet filter OUTPUT 100 -j DROP
|
||
Voulez-vous que je vous régénère tout le script corrigé (avec inet partout) pour que vous puissiez le relancer directement, ou préférez-vous seulement corriger à la main vos lignes existantes ?
|
||
Vous avez dit :
|
||
udo firewall-cmd --direct --add-rule ipv4 filter OUTPUT 0s -o lo -j ACCEPT
|
||
usage: --direct --add-rule { ipv4 | ipv6 | eb } <table> <chain> <priority> <args>
|
||
ChatGPT a dit :
|
||
La cause immédiate est une petite faute de frappe — vous avez tapé 0s au lieu de 0 — et la commande attend des arguments dans l’ordre exact : family table chain priority args. Selon la version de firewall-cmd votre family peut être ipv4/ipv6/eb ou inet. Voici les corrections et exemples prêts à coller.
|
||
1) Correction immédiate (si votre firewall-cmd accepte ipv4)
|
||
# loopback (immédiat)
|
||
sudo firewall-cmd --direct --add-rule ipv4 filter OUTPUT 0 -o lo -j ACCEPT
|
||
|
||
# loopback (permanent)
|
||
sudo firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT 0 -o lo -j ACCEPT
|
||
2) Si votre firewall-cmd réclame inet (certaines versions récentes)
|
||
# loopback (immédiat)
|
||
sudo firewall-cmd --direct --add-rule inet filter OUTPUT 0 -o lo -j ACCEPT
|
||
|
||
# loopback (permanent)
|
||
sudo firewall-cmd --permanent --direct --add-rule inet filter OUTPUT 0 -o lo -j ACCEPT
|
||
3) Exemple des autres règles (choisissez ipv4 ou inet selon votre système)
|
||
Remplacez <FAMILY> par ipv4 ou inet.
|
||
# allow established/related
|
||
sudo firewall-cmd --direct --add-rule <FAMILY> filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
sudo firewall-cmd --permanent --direct --add-rule <FAMILY> filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
|
||
# DNS UDP/TCP vers $DNS_IP
|
||
sudo firewall-cmd --direct --add-rule <FAMILY> filter OUTPUT 5 -p udp -d $DNS_IP --dport 53 -j ACCEPT
|
||
sudo firewall-cmd --permanent --direct --add-rule <FAMILY> filter OUTPUT 5 -p udp -d $DNS_IP --dport 53 -j ACCEPT
|
||
sudo firewall-cmd --direct --add-rule <FAMILY> filter OUTPUT 6 -p tcp -d $DNS_IP --dport 53 -j ACCEPT
|
||
sudo firewall-cmd --permanent --direct --add-rule <FAMILY> filter OUTPUT 6 -p tcp -d $DNS_IP --dport 53 -j ACCEPT
|
||
|
||
# Allow proxy (ex: 172.31.10.23:3128) and 443->proxy
|
||
sudo firewall-cmd --direct --add-rule <FAMILY> filter OUTPUT 10 -p tcp -d 172.31.10.23 --dport 3128 -j ACCEPT
|
||
sudo firewall-cmd --permanent --direct --add-rule <FAMILY> filter OUTPUT 10 -p tcp -d 172.31.10.23 --dport 3128 -j ACCEPT
|
||
sudo firewall-cmd --direct --add-rule <FAMILY> filter OUTPUT 11 -p tcp -d 172.31.10.23 --dport 443 -j ACCEPT
|
||
sudo firewall-cmd --permanent --direct --add-rule <FAMILY> filter OUTPUT 11 -p tcp -d 172.31.10.23 --dport 443 -j ACCEPT
|
||
|
||
# final DROP
|
||
sudo firewall-cmd --direct --add-rule <FAMILY> filter OUTPUT 100 -j DROP
|
||
sudo firewall-cmd --permanent --direct --add-rule <FAMILY> filter OUTPUT 100 -j DROP
|
||
4) Lister / supprimer les règles direct
|
||
# lister toutes les rules direct en cours
|
||
sudo firewall-cmd --direct --get-all-rules
|
||
|
||
# supprimer une règle (mêmes arguments mais --remove-rule)
|
||
sudo firewall-cmd --direct --remove-rule <FAMILY> filter OUTPUT 0 -o lo -j ACCEPT
|
||
sudo firewall-cmd --permanent --direct --remove-rule <FAMILY> filter OUTPUT 0 -o lo -j ACCEPT
|
||
5) Reload des règles permanentes
|
||
sudo firewall-cmd --reload
|
||
Si vous voulez, je peux :
|
||
vous générer tout le script corrigé avec inet ou ipv4 selon ce que votre machine accepte, prêt à exécuter ;
|
||
ou vérifier la sortie de firewall-cmd --version / firewall-cmd --help que vous collez ici et vous rendre le script adapté.
|
||
Laquelle préférez-vous ?
|
||
Vous avez dit :
|
||
vérifier la sortie de firewall-cmd --version / firewall-cmd --help que vous collez ici et vous rendre le script adapté.
|
||
ChatGPT a dit :
|
||
Parfait 👍 Pour que je génère un script corrigé et sûr :
|
||
Pouvez-vous lancer sur votre serveur :
|
||
firewall-cmd --version
|
||
firewall-cmd --help | head -20
|
||
Copiez-collez ici la sortie complète.
|
||
Avec ces infos je verrai :
|
||
quelle version de firewalld est installée,
|
||
si vos --direct --add-rule attendent ipv4/ipv6 ou bien inet (différence majeure entre RHEL 8/9/10 et les backends nftables/iptables).
|
||
Ensuite je vous renvoie un script adapté à votre version exacte de firewalld.
|
||
👉 Voulez-vous que je prévois aussi une règle de secours (par ex. pas de DROP final au début) pour tester sans risque de vous couper Internet ?
|
||
|
||
Vous avez dit :
|
||
vous générer tout le script corrigé avec inet ou ipv4 selon ce que votre machine accepte, prêt à exécuter ;
|
||
ChatGPT a dit :
|
||
Parfait ✅ Je vais vous fournir deux variantes du script : une avec inet (si votre firewalld utilise nftables backend) et une avec ipv4 (si c’est encore iptables backend).
|
||
👉 La seule différence est le mot clé FAMILY.
|
||
|
||
Testez une seule commande :
|
||
sudo firewall-cmd --direct --add-rule inet filter OUTPUT 0 -o lo -j ACCEPT
|
||
Si ça passe, utilisez la version inet.
|
||
Si ça échoue avec INVALID_IPV, utilisez la version ipv4.
|
||
Script firewall avec FAMILY=inet
|
||
(enregistrez sous apply-egress-firewall.sh, chmod +x, exécutez avec sudo ./apply-egress-firewall.sh)
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
FAMILY="inet" # mettez ipv4 si inet ne fonctionne pas
|
||
PROXY_IP="172.31.10.23"
|
||
PROXY_PORT="3128"
|
||
DNS_IP=$(awk '/^nameserver/ {print $2; exit}' /etc/resolv.conf)
|
||
MGMT_IP=$(echo $SSH_CLIENT | awk '{print $1}')
|
||
NTP_IP="pool.ntp.org"
|
||
|
||
echo "[INFO] Utilisation FAMILY=$FAMILY PROXY=$PROXY_IP:$PROXY_PORT DNS=$DNS_IP MGMT=$MGMT_IP"
|
||
|
||
# Autoriser SSH depuis IP management (INPUT)
|
||
firewall-cmd --add-rich-rule="rule family='ipv4' source address='$MGMT_IP' service name='ssh' accept"
|
||
firewall-cmd --permanent --add-rich-rule="rule family='ipv4' source address='$MGMT_IP' service name='ssh' accept"
|
||
|
||
# Loopback
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 0 -o lo -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 0 -o lo -j ACCEPT
|
||
|
||
# Established/Related
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
|
||
|
||
# DNS
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 5 -p udp -d $DNS_IP --dport 53 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 5 -p udp -d $DNS_IP --dport 53 -j ACCEPT
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 6 -p tcp -d $DNS_IP --dport 53 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 6 -p tcp -d $DNS_IP --dport 53 -j ACCEPT
|
||
|
||
# Proxy
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 10 -p tcp -d $PROXY_IP --dport $PROXY_PORT -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 10 -p tcp -d $PROXY_IP --dport $PROXY_PORT -j ACCEPT
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 11 -p tcp -d $PROXY_IP --dport 443 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 11 -p tcp -d $PROXY_IP --dport 443 -j ACCEPT
|
||
|
||
# NTP (large autorisation si host, sinon préciser IP)
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 15 -p udp --dport 123 -j ACCEPT
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 15 -p udp --dport 123 -j ACCEPT
|
||
|
||
# Log avant drop (limité)
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 90 -m limit --limit 2/min -j LOG --log-prefix "EGRESS-DROP: " --log-level 4
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 90 -m limit --limit 2/min -j LOG --log-prefix "EGRESS-DROP: " --log-level 4
|
||
|
||
# Drop tout le reste
|
||
firewall-cmd --direct --add-rule $FAMILY filter OUTPUT 100 -j DROP
|
||
firewall-cmd --permanent --direct --add-rule $FAMILY filter OUTPUT 100 -j DROP
|
||
|
||
firewall-cmd --reload
|
||
echo "[INFO] Règles appliquées. Vérifiez avec: firewall-cmd --direct --get-all-rules"
|
||
Script firewall avec FAMILY=ipv4
|
||
(changez juste la variable FAMILY)
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
FAMILY="ipv4"
|
||
# le reste identique au script précédent...
|
||
✅ Étapes pour vous :
|
||
Testez une seule commande avec inet (loopback).
|
||
Si ça passe → utilisez le script version inet.
|
||
Sinon → utilisez le script version ipv4.
|
||
Voulez-vous que je vous génère directement le script complet final uniquement avec inet, prêt à coller, pour éviter d’avoir à éditer ?
|
||
Vous avez dit :
|
||
sudo firewall-cmd --direct --add-rule inet filter OUTPUT 0 -o lo -j ACCEPT
|
||
Error: INVALID_IPV: invalid argument: inet (choose from 'ipv4', 'ipv6', 'eb')
|
||
gilles@minikube ~ $ sudo firewall-cmd --direct --add-rule ipv4 filter OUTPUT 0 -o lo -j ACCEPT
|
||
Error: INVALID_IPV: 'ipv4' is not a valid backend or is unavailable
|
||
gilles@minikube ~ $ sudo firewall-cmd --direct --add-rule eb filter OUTPUT 0 -o lo -j ACCEPT
|
||
Error: INVALID_IPV: 'eb' is not a valid backend or is unavailable
|
||
gilles@minikube ~ $ sudo firewall-cmd --direct --add-rule ipv6 filter OUTPUT 0 -o lo -j ACCEPT
|
||
Error: INVALID_IPV: 'ipv6' is not a valid backend or is unavailable
|
||
ChatGPT a dit :
|
||
Parfait, merci pour ces tests 🙏
|
||
L’erreur que vous voyez (INVALID_IPV) indique que votre firewalld tourne avec le backend nftables pur. Dans ce mode, les commandes --direct ne gèrent plus ipv4/ipv6/inet — elles sont désactivées.
|
||
👉 Concrètement :
|
||
|
||
--direct était pensé pour iptables/ebtables, donc incompatible avec nftables.
|
||
Sur RHEL 9/10 / Fedora récentes, backend par défaut = nftables → il faut utiliser rich rules ou policies à la place.
|
||
✅ Solution adaptée à nftables backend (sans --direct)
|
||
Vous pouvez tout faire avec des règles riches (rich rules) et zones. Exemple pour votre cas :
|
||
# Autoriser loopback
|
||
sudo firewall-cmd --add-rich-rule='rule family="ipv4" output interface="lo" accept'
|
||
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" output interface="lo" accept'
|
||
|
||
# Autoriser connexions établies/relatives → déjà implicite en nftables backend
|
||
|
||
# Autoriser DNS
|
||
sudo firewall-cmd --add-rich-rule='rule family="ipv4" destination address=8.8.8.8 port port=53 protocol=udp accept'
|
||
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" destination address=8.8.8.8 port port=53 protocol=udp accept'
|
||
|
||
# Autoriser proxy
|
||
sudo firewall-cmd --add-rich-rule='rule family="ipv4" destination address=172.31.10.23 port port=3128 protocol=tcp accept'
|
||
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" destination address=172.31.10.23 port port=3128 protocol=tcp accept'
|
||
|
||
# Autoriser NTP
|
||
sudo firewall-cmd --add-rich-rule='rule family="ipv4" port port=123 protocol=udp accept'
|
||
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" port port=123 protocol=udp accept'
|
||
|
||
# Tout bloquer par défaut (DROP)
|
||
sudo firewall-cmd --set-default-zone=drop
|
||
🚩 Important
|
||
Le mode drop comme zone par défaut rejette tout sauf ce que vous autorisez explicitement.
|
||
Les rich rules ci-dessus vous permettent d’autoriser uniquement loopback, DNS, proxy, NTP, etc.
|
||
Vous n’avez plus besoin du bloc --direct.
|
||
👉 Je peux vous générer un script complet prêt à exécuter pour nftables backend avec firewalld (utilisant uniquement rich rules + zone drop).
|
||
Voulez-vous que je vous prépare ce script ?
|
||
|
||
Vous avez dit :
|
||
sudo firewall-cmd --add-rich-rule='rule family="ipv4" output interface="lo" accept'
|
||
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" output interface="lo" accept'
|
||
Error: INVALID_RULE: unknown element output
|
||
Error: INVALID_RULE: unknown element output
|
||
ChatGPT a dit :
|
||
Ah ! Maintenant c’est clair 😅
|
||
Avec firewalld en mode nftables, les rich rules ne gèrent pas la direction output, elles ne peuvent gérer que :
|
||
|
||
source, destination, service, port, icmp-type, log, etc.
|
||
Elles s’appliquent via les zones (INPUT/OUTPUT/FORWARD sont implicites selon la zone).
|
||
Autrement dit : sur les serveurs récents (Minikube, RHEL 10, Fedora 38+) il n’y a plus de possibilité simple avec --direct ou rich rules output pour filtrer le trafic sortant avec firewalld.
|
||
🔹 Solution pratique pour votre objectif (forcer usage du proxy)
|
||
Configurer les applications pour utiliser le proxy
|
||
/etc/environment
|
||
/etc/profile.d/proxy.sh
|
||
/etc/dnf/dnf.conf
|
||
Bloquer le trafic sortant en dehors du proxy → vous devez passer par nftables directement au lieu de firewalld.
|
||
Exemple simple en nftables nat/forward/output :
|
||
sudo nft add table inet filter
|
||
sudo nft add chain inet filter output { type filter hook output priority 0 \; policy drop \; }
|
||
sudo nft add rule inet filter output oif lo accept
|
||
sudo nft add rule inet filter output ip daddr 172.31.10.23 tcp dport 3128 accept
|
||
sudo nft add rule inet filter output ip daddr <DNS_IP> udp dport 53 accept
|
||
sudo nft add rule inet filter output ip daddr <DNS_IP> tcp dport 53 accept
|
||
Ici :
|
||
policy drop → bloque tout par défaut
|
||
on autorise loopback, DNS interne, proxy.
|
||
En résumé :
|
||
firewalld nftables backend = --direct et output rich rules ne fonctionnent plus.
|
||
Pour contrôler strictement l’OUTPUT → utiliser nftables directement.
|
||
Firewalld peut encore gérer INPUT/FORWARD via zones et rich rules, mais pas le contrôle fin du trafic sortant.
|
||
Si vous voulez, je peux vous générer un script complet nftables qui :
|
||
autorise loopback, proxy (172.31.10.23:3128), DNS interne, NTP
|
||
bloque tout le reste en sortie
|
||
prêt à coller sur votre serveur Minikube ou RHEL 10.
|
||
Voulez que je fasse ça ?
|
||
Vous avez dit :
|
||
volontiers mais laisser le port 22 ouverts
|
||
ChatGPT a dit :
|
||
Parfait ✅ Voici un script nftables complet prêt à exécuter pour votre serveur.
|
||
Sortie (OUTPUT) : tout est bloqué par défaut sauf :
|
||
Loopback (lo)
|
||
Proxy 172.31.10.23:3128
|
||
DNS interne (<DNS_IP>, à remplacer)
|
||
NTP (123/udp)
|
||
SSH sortant (22/tcp) pour ne pas vous bloquer
|
||
Entrée (INPUT) : on laisse le port 22/tcp ouvert pour pouvoir administrer le serveur.
|
||
Vous pouvez adapter les IP de DNS et NTP selon votre réseau.
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# ---------------------- CONFIG ----------------------
|
||
PROXY_IP="172.31.10.23"
|
||
PROXY_PORT="3128"
|
||
DNS_IP="10.0.0.10" # Remplacez par votre DNS interne
|
||
NTP_IP="10.0.0.11" # Remplacez par votre serveur NTP interne si besoin
|
||
SSH_ALLOWED_IP="0.0.0.0/0" # Autoriser SSH depuis n'importe où, ajustez si nécessaire
|
||
# ---------------------------------------------------
|
||
|
||
echo "[INFO] Sauvegarde de l'état nftables actuel"
|
||
sudo nft list ruleset > "/root/nftables-backup-$(date +%Y%m%d-%H%M%S).txt"
|
||
|
||
echo "[INFO] Création de la table et chaînes"
|
||
sudo nft flush ruleset
|
||
sudo nft add table inet filter
|
||
|
||
# INPUT chain : autoriser SSH
|
||
sudo nft add chain inet filter input { type filter hook input priority 0 \; policy drop \; }
|
||
sudo nft add rule inet filter input tcp dport 22 ip saddr $SSH_ALLOWED_IP accept
|
||
sudo nft add rule inet filter input ct state established,related accept
|
||
|
||
# OUTPUT chain : policy drop
|
||
sudo nft add chain inet filter output { type filter hook output priority 0 \; policy drop \; }
|
||
|
||
# OUTPUT rules
|
||
sudo nft add rule inet filter output oif lo accept # loopback
|
||
sudo nft add rule inet filter output tcp dport 22 accept # SSH sortant
|
||
sudo nft add rule inet filter output ip daddr $PROXY_IP tcp dport $PROXY_PORT accept # Proxy
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP udp dport 53 accept # DNS UDP
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP tcp dport 53 accept # DNS TCP
|
||
sudo nft add rule inet filter output ip daddr $NTP_IP udp dport 123 accept # NTP
|
||
|
||
# Permettre les réponses aux connexions établies
|
||
sudo nft add rule inet filter output ct state established,related accept
|
||
|
||
echo "[INFO] État final des règles nftables"
|
||
sudo nft list ruleset
|
||
|
||
echo "[INFO] Script terminé. Tout le trafic non explicitement autorisé est bloqué."
|
||
🔹 Instructions
|
||
Remplacez DNS_IP et NTP_IP par vos adresses internes.
|
||
Sauvegardez ce script, par exemple :
|
||
sudo nano /root/setup-egress-nftables.sh
|
||
sudo chmod +x /root/setup-egress-nftables.sh
|
||
Exécutez :
|
||
sudo /root/setup-egress-nftables.sh
|
||
Vérifiez :
|
||
nft list ruleset
|
||
curl --proxy http://172.31.10.23:3128 http://example.com # doit fonctionner
|
||
curl http://example.com # doit échouer
|
||
Si vous voulez, je peux vous générer une version améliorée qui détecte automatiquement votre interface réseau et votre DNS actuel pour éviter toute configuration manuelle.
|
||
Voulez que je fasse ça ?
|
||
|
||
Vous avez dit :
|
||
oui
|
||
ChatGPT a dit :
|
||
Super 👍 Voici une version améliorée et automatisée du script nftables :
|
||
Détecte automatiquement :
|
||
interface réseau (DEFAULT_IF)
|
||
serveur DNS dans /etc/resolv.conf
|
||
Utilise le proxy 172.31.10.23:3128
|
||
Autorise loopback, DNS détecté, NTP (pool.ntp.org résolu automatiquement), SSH (entrant + sortant)
|
||
Bloque tout le reste en sortie
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# ---------------------- CONFIG ----------------------
|
||
PROXY_IP="172.31.10.23"
|
||
PROXY_PORT="3128"
|
||
SSH_ALLOWED_IP="0.0.0.0/0" # Ajustez si vous voulez restreindre l'accès SSH entrant
|
||
# ---------------------------------------------------
|
||
|
||
# Détection automatique de l'interface principale
|
||
DEFAULT_IF=$(ip route | awk '/^default/ {print $5; exit}')
|
||
# Détection du DNS utilisé
|
||
DNS_IP=$(awk '/^nameserver/ {print $2; exit}' /etc/resolv.conf)
|
||
# Résolution de pool.ntp.org -> prend la première IP trouvée
|
||
NTP_IP=$(getent ahostsv4 pool.ntp.org | awk '{print $1; exit}')
|
||
|
||
echo "[INFO] Interface réseau détectée : $DEFAULT_IF"
|
||
echo "[INFO] DNS détecté : $DNS_IP"
|
||
echo "[INFO] NTP résolu : $NTP_IP"
|
||
|
||
echo "[INFO] Sauvegarde de l'état nftables actuel"
|
||
sudo nft list ruleset > "/root/nftables-backup-$(date +%Y%m%d-%H%M%S).txt"
|
||
|
||
echo "[INFO] Réinitialisation et création de la table"
|
||
sudo nft flush ruleset
|
||
sudo nft add table inet filter
|
||
|
||
# INPUT : SSH + established
|
||
sudo nft add chain inet filter input { type filter hook input priority 0 \; policy drop \; }
|
||
sudo nft add rule inet filter input tcp dport 22 ip saddr $SSH_ALLOWED_IP accept
|
||
sudo nft add rule inet filter input ct state established,related accept
|
||
|
||
# OUTPUT : policy drop
|
||
sudo nft add chain inet filter output { type filter hook output priority 0 \; policy drop \; }
|
||
|
||
# Autorisations OUTPUT
|
||
sudo nft add rule inet filter output oif lo accept # Loopback
|
||
sudo nft add rule inet filter output tcp dport 22 accept # SSH sortant
|
||
sudo nft add rule inet filter output ip daddr $PROXY_IP tcp dport $PROXY_PORT accept # Proxy
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP udp dport 53 accept # DNS UDP
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP tcp dport 53 accept # DNS TCP
|
||
sudo nft add rule inet filter output ip daddr $NTP_IP udp dport 123 accept # NTP
|
||
sudo nft add rule inet filter output ct state established,related accept # Réponses aux connexions
|
||
|
||
echo "[INFO] État final des règles nftables :"
|
||
sudo nft list ruleset
|
||
|
||
echo "[INFO] Script terminé. Tout le trafic sortant est bloqué sauf : loopback, proxy, DNS, NTP et SSH."
|
||
🚀 Utilisation
|
||
Sauvegardez le script :
|
||
sudo nano /root/setup-nftables-proxy.sh
|
||
sudo chmod +x /root/setup-nftables-proxy.sh
|
||
Exécutez :
|
||
sudo /root/setup-nftables-proxy.sh
|
||
Vérifiez :
|
||
nft list ruleset
|
||
curl --proxy http://172.31.10.23:3128 http://example.com # doit réussir
|
||
curl http://example.com # doit échouer
|
||
👉 Voulez-vous que je vous prépare aussi la persistance de ces règles nftables (au reboot) pour RHEL/Alma/Rocky/Minikube (systemd service nftables.service) ?
|
||
Vous avez dit :
|
||
rajouter la règle pour autoriser un point de montage cifs sur myhomecloud.gmotech.net
|
||
ChatGPT a dit :
|
||
Très bien 👍 Pour monter un partage CIFS/SMB, il faut laisser passer le trafic sortant vers le serveur concerné (myhomecloud.gmotech.net) sur les ports suivants :
|
||
445/tcp → port principal SMB/CIFS
|
||
(optionnel si vieux clients : 139/tcp, mais aujourd’hui 445 suffit généralement)
|
||
On va donc :
|
||
Résoudre l’IP de myhomecloud.gmotech.net automatiquement (comme pour NTP).
|
||
Autoriser l’OUTPUT vers cette IP sur tcp dport 445.
|
||
Script mis à jour (ajout CIFS)
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# ---------------------- CONFIG ----------------------
|
||
PROXY_IP="172.31.10.23"
|
||
PROXY_PORT="3128"
|
||
SSH_ALLOWED_IP="0.0.0.0/0" # Ajustez si vous voulez restreindre l'accès SSH entrant
|
||
# ---------------------------------------------------
|
||
|
||
# Détection automatique de l'interface principale
|
||
DEFAULT_IF=$(ip route | awk '/^default/ {print $5; exit}')
|
||
# Détection du DNS utilisé
|
||
DNS_IP=$(awk '/^nameserver/ {print $2; exit}' /etc/resolv.conf)
|
||
# Résolution de pool.ntp.org -> prend la première IP trouvée
|
||
NTP_IP=$(getent ahostsv4 pool.ntp.org | awk '{print $1; exit}')
|
||
# Résolution de myhomecloud.gmotech.net
|
||
CIFS_IP=$(getent ahostsv4 myhomecloud.gmotech.net | awk '{print $1; exit}')
|
||
|
||
echo "[INFO] Interface réseau détectée : $DEFAULT_IF"
|
||
echo "[INFO] DNS détecté : $DNS_IP"
|
||
echo "[INFO] NTP résolu : $NTP_IP"
|
||
echo "[INFO] CIFS serveur résolu : $CIFS_IP"
|
||
|
||
echo "[INFO] Sauvegarde de l'état nftables actuel"
|
||
sudo nft list ruleset > "/root/nftables-backup-$(date +%Y%m%d-%H%M%S).txt"
|
||
|
||
echo "[INFO] Réinitialisation et création de la table"
|
||
sudo nft flush ruleset
|
||
sudo nft add table inet filter
|
||
|
||
# INPUT : SSH + established
|
||
sudo nft add chain inet filter input { type filter hook input priority 0 \; policy drop \; }
|
||
sudo nft add rule inet filter input tcp dport 22 ip saddr $SSH_ALLOWED_IP accept
|
||
sudo nft add rule inet filter input ct state established,related accept
|
||
|
||
# OUTPUT : policy drop
|
||
sudo nft add chain inet filter output { type filter hook output priority 0 \; policy drop \; }
|
||
|
||
# Autorisations OUTPUT
|
||
sudo nft add rule inet filter output oif lo accept # Loopback
|
||
sudo nft add rule inet filter output tcp dport 22 accept # SSH sortant
|
||
sudo nft add rule inet filter output ip daddr $PROXY_IP tcp dport $PROXY_PORT accept # Proxy
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP udp dport 53 accept # DNS UDP
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP tcp dport 53 accept # DNS TCP
|
||
sudo nft add rule inet filter output ip daddr $NTP_IP udp dport 123 accept # NTP
|
||
sudo nft add rule inet filter output ip daddr $CIFS_IP tcp dport 445 accept # CIFS/SMB
|
||
sudo nft add rule inet filter output ct state established,related accept # Réponses aux connexions
|
||
|
||
echo "[INFO] État final des règles nftables :"
|
||
sudo nft list ruleset
|
||
|
||
echo "[INFO] Script terminé. Tout le trafic sortant est bloqué sauf : loopback, proxy, DNS, NTP, SSH et CIFS vers myhomecloud.gmotech.net."
|
||
🚀 Vérification après exécution
|
||
Lancez le script :
|
||
sudo /root/setup-nftables-proxy.sh
|
||
Vérifiez que le montage CIFS fonctionne :
|
||
sudo mount -t cifs //myhomecloud.gmotech.net/partage /mnt/cifs -o user=monuser
|
||
Vérifiez que le reste du trafic sortant est bien bloqué.
|
||
👉 Voulez-vous que j’ajoute aussi l’option de persistance (sauvegarde auto de ces règles avec nftables.service au reboot) directement dans ce script ?
|
||
Vous avez dit :
|
||
autoriser le ping
|
||
ChatGPT a dit :
|
||
Bonne remarque 👍
|
||
Le ping utilise :
|
||
|
||
ICMP echo-request en sortie
|
||
ICMP echo-reply en entrée
|
||
Vu que notre script met les politiques DROP, il faut donc :
|
||
autoriser icmp type echo-request dans OUTPUT
|
||
autoriser icmp type echo-reply dans INPUT
|
||
🔹 Script corrigé avec ping autorisé
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# ---------------------- CONFIG ----------------------
|
||
PROXY_IP="172.31.10.23"
|
||
PROXY_PORT="3128"
|
||
SSH_ALLOWED_IP="0.0.0.0/0" # Ajustez si vous voulez restreindre l'accès SSH entrant
|
||
# ---------------------------------------------------
|
||
|
||
# Détection automatique de l'interface principale
|
||
DEFAULT_IF=$(ip route | awk '/^default/ {print $5; exit}')
|
||
# Détection du DNS utilisé
|
||
DNS_IP=$(awk '/^nameserver/ {print $2; exit}' /etc/resolv.conf)
|
||
# Résolution de pool.ntp.org -> prend la première IP trouvée
|
||
NTP_IP=$(getent ahostsv4 pool.ntp.org | awk '{print $1; exit}')
|
||
# Résolution de myhomecloud.gmotech.net
|
||
CIFS_IP=$(getent ahostsv4 myhomecloud.gmotech.net | awk '{print $1; exit}')
|
||
|
||
echo "[INFO] Interface réseau détectée : $DEFAULT_IF"
|
||
echo "[INFO] DNS détecté : $DNS_IP"
|
||
echo "[INFO] NTP résolu : $NTP_IP"
|
||
echo "[INFO] CIFS serveur résolu : $CIFS_IP"
|
||
|
||
echo "[INFO] Sauvegarde de l'état nftables actuel"
|
||
sudo nft list ruleset > "/root/nftables-backup-$(date +%Y%m%d-%H%M%S).txt"
|
||
|
||
echo "[INFO] Réinitialisation et création de la table"
|
||
sudo nft flush ruleset
|
||
sudo nft add table inet filter
|
||
|
||
# INPUT : SSH + established + icmp echo-reply
|
||
sudo nft add chain inet filter input { type filter hook input priority 0 \; policy drop \; }
|
||
sudo nft add rule inet filter input tcp dport 22 ip saddr $SSH_ALLOWED_IP accept
|
||
sudo nft add rule inet filter input ct state established,related accept
|
||
sudo nft add rule inet filter input icmp type echo-reply accept # réponse ping
|
||
|
||
# OUTPUT : policy drop
|
||
sudo nft add chain inet filter output { type filter hook output priority 0 \; policy drop \; }
|
||
|
||
# Autorisations OUTPUT
|
||
sudo nft add rule inet filter output oif lo accept # Loopback
|
||
sudo nft add rule inet filter output tcp dport 22 accept # SSH sortant
|
||
sudo nft add rule inet filter output ip daddr $PROXY_IP tcp dport $PROXY_PORT accept # Proxy
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP udp dport 53 accept # DNS UDP
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP tcp dport 53 accept # DNS TCP
|
||
sudo nft add rule inet filter output ip daddr $NTP_IP udp dport 123 accept # NTP
|
||
sudo nft add rule inet filter output ip daddr $CIFS_IP tcp dport 445 accept # CIFS/SMB
|
||
sudo nft add rule inet filter output icmp type echo-request accept # ping sortant
|
||
sudo nft add rule inet filter output ct state established,related accept # Réponses aux connexions
|
||
|
||
echo "[INFO] État final des règles nftables :"
|
||
sudo nft list ruleset
|
||
|
||
echo "[INFO] Script terminé. Autorisé : loopback, proxy, DNS, NTP, SSH, CIFS et ping. Tout le reste est bloqué."
|
||
🚀 Vérification après exécution
|
||
Exécutez le script :
|
||
sudo /root/setup-nftables-proxy.sh
|
||
Testez :
|
||
ping -c 4 8.8.8.8
|
||
ping -c 4 myhomecloud.gmotech.net
|
||
👉 Voulez-vous que je vous prépare maintenant une persistance automatique (sauvegarde dans /etc/nftables.conf pour que vos règles survivent aux reboots) ?
|
||
Vous avez dit :
|
||
autoriser l'envoi de mail port 25 et 587
|
||
ChatGPT a dit :
|
||
Parfait 👍 vous voulez donc permettre à votre serveur d’envoyer des mails en direct via SMTP :
|
||
25/tcp → SMTP standard (souvent bloqué par les FAI mais utilisé entre serveurs)
|
||
587/tcp → submission (utilisé par les clients vers un relais SMTP authentifié)
|
||
On va simplement ajouter deux règles OUTPUT autorisant ces ports.
|
||
🔹 Script complet mis à jour (avec SMTP, ping, CIFS, proxy, DNS, NTP, SSH)
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# ---------------------- CONFIG ----------------------
|
||
PROXY_IP="172.31.10.23"
|
||
PROXY_PORT="3128"
|
||
SSH_ALLOWED_IP="0.0.0.0/0" # Ajustez si vous voulez restreindre l'accès SSH entrant
|
||
# ---------------------------------------------------
|
||
|
||
# Détection automatique de l'interface principale
|
||
DEFAULT_IF=$(ip route | awk '/^default/ {print $5; exit}')
|
||
# Détection du DNS utilisé
|
||
DNS_IP=$(awk '/^nameserver/ {print $2; exit}' /etc/resolv.conf)
|
||
# Résolution de pool.ntp.org -> prend la première IP trouvée
|
||
NTP_IP=$(getent ahostsv4 pool.ntp.org | awk '{print $1; exit}')
|
||
# Résolution de myhomecloud.gmotech.net
|
||
CIFS_IP=$(getent ahostsv4 myhomecloud.gmotech.net | awk '{print $1; exit}')
|
||
|
||
echo "[INFO] Interface réseau détectée : $DEFAULT_IF"
|
||
echo "[INFO] DNS détecté : $DNS_IP"
|
||
echo "[INFO] NTP résolu : $NTP_IP"
|
||
echo "[INFO] CIFS serveur résolu : $CIFS_IP"
|
||
|
||
echo "[INFO] Sauvegarde de l'état nftables actuel"
|
||
sudo nft list ruleset > "/root/nftables-backup-$(date +%Y%m%d-%H%M%S).txt"
|
||
|
||
echo "[INFO] Réinitialisation et création de la table"
|
||
sudo nft flush ruleset
|
||
sudo nft add table inet filter
|
||
|
||
# INPUT : SSH + established + icmp echo-reply
|
||
sudo nft add chain inet filter input { type filter hook input priority 0 \; policy drop \; }
|
||
sudo nft add rule inet filter input tcp dport 22 ip saddr $SSH_ALLOWED_IP accept
|
||
sudo nft add rule inet filter input ct state established,related accept
|
||
sudo nft add rule inet filter input icmp type echo-reply accept # réponse ping
|
||
|
||
# OUTPUT : policy drop
|
||
sudo nft add chain inet filter output { type filter hook output priority 0 \; policy drop \; }
|
||
|
||
# Autorisations OUTPUT
|
||
sudo nft add rule inet filter output oif lo accept # Loopback
|
||
sudo nft add rule inet filter output tcp dport 22 accept # SSH sortant
|
||
sudo nft add rule inet filter output ip daddr $PROXY_IP tcp dport $PROXY_PORT accept # Proxy
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP udp dport 53 accept # DNS UDP
|
||
sudo nft add rule inet filter output ip daddr $DNS_IP tcp dport 53 accept # DNS TCP
|
||
sudo nft add rule inet filter output ip daddr $NTP_IP udp dport 123 accept # NTP
|
||
sudo nft add rule inet filter output ip daddr $CIFS_IP tcp dport 445 accept # CIFS/SMB
|
||
sudo nft add rule inet filter output icmp type echo-request accept # ping sortant
|
||
sudo nft add rule inet filter output tcp dport 25 accept # SMTP (port 25)
|
||
sudo nft add rule inet filter output tcp dport 587 accept # SMTP submission (587)
|
||
sudo nft add rule inet filter output ct state established,related accept # Réponses aux connexions
|
||
|
||
echo "[INFO] État final des règles nftables :"
|
||
sudo nft list ruleset
|
||
|
||
echo "[INFO] Script terminé. Autorisé : loopback, proxy, DNS, NTP, SSH, CIFS, ping et SMTP (25,587). Tout le reste est bloqué."
|
||
🚀 Vérifications
|
||
Lancez le script :
|
||
sudo /root/setup-nftables-proxy.sh
|
||
Vérifiez que l’envoi de mail fonctionne (exemple avec telnet) :
|
||
telnet smtp.gmail.com 587
|
||
telnet <votre-relay-smtp> 25
|
||
Vérifiez que tout le reste est bien bloqué.
|
||
👉 Voulez-vous que je vous génère aussi la persistance automatique dans /etc/nftables.conf pour que ces règles survivent aux redémarrages ?
|
||
Vous avez dit :
|
||
oui
|
||
ChatGPT a dit :
|
||
Parfait 👍 On va rendre vos règles persistantes grâce au service système nftables.service.
|
||
🔹 Étapes pour persister vos règles
|
||
Sauvegarder les règles actuelles dans le fichier de configuration :
|
||
sudo mkdir -p /etc/nftables
|
||
sudo nft list ruleset > /etc/nftables.conf
|
||
Activer le service nftables (il recharge automatiquement /etc/nftables.conf au démarrage) :
|
||
sudo systemctl enable nftables
|
||
sudo systemctl start nftables
|
||
Vérifier :
|
||
sudo systemctl status nftables
|
||
sudo nft list ruleset
|
||
🔹 Version finale du script (avec persistance auto incluse)
|
||
Voici un script complet qui applique vos règles et les rend persistantes :
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
|
||
# ---------------------- CONFIG ----------------------
|
||
PROXY_IP="172.31.10.23"
|
||
PROXY_PORT="3128"
|
||
SSH_ALLOWED_IP="0.0.0.0/0" # Ajustez si vous voulez restreindre l'accès SSH entrant
|
||
# ---------------------------------------------------
|
||
|
||
# Détection automatique de l'interface principale
|
||
DEFAULT_IF=$(ip route | awk '/^default/ {print $5; exit}')
|
||
DNS_IP=$(awk '/^nameserver/ {print $2; exit}' /etc/resolv.conf)
|
||
NTP_IP=$(getent ahostsv4 pool.ntp.org | awk '{print $1; exit}')
|
||
CIFS_IP=$(getent ahostsv4 myhomecloud.gmotech.net | awk '{print $1; exit}')
|
||
|
||
echo "[INFO] Interface réseau détectée : $DEFAULT_IF"
|
||
echo "[INFO] DNS détecté : $DNS_IP"
|
||
echo "[INFO] NTP résolu : $NTP_IP"
|
||
echo "[INFO] CIFS serveur résolu : $CIFS_IP"
|
||
|
||
# Sauvegarde de l'ancien ruleset
|
||
sudo nft list ruleset > "/root/nftables-backup-$(date +%Y%m%d-%H%M%S).txt"
|
||
|
||
# Création du fichier de config nftables persistante
|
||
sudo tee /etc/nftables.conf > /dev/null <<EOF
|
||
#!/usr/sbin/nft -f
|
||
|
||
flush ruleset
|
||
|
||
table inet filter {
|
||
chain input {
|
||
type filter hook input priority 0;
|
||
policy drop;
|
||
|
||
tcp dport 22 ip saddr $SSH_ALLOWED_IP accept
|
||
ct state established,related accept
|
||
icmp type echo-reply accept
|
||
}
|
||
|
||
chain output {
|
||
type filter hook output priority 0;
|
||
policy drop;
|
||
|
||
oif lo accept
|
||
tcp dport 22 accept
|
||
ip daddr $PROXY_IP tcp dport $PROXY_PORT accept
|
||
ip daddr $DNS_IP udp dport 53 accept
|
||
ip daddr $DNS_IP tcp dport 53 accept
|
||
ip daddr $NTP_IP udp dport 123 accept
|
||
ip daddr $CIFS_IP tcp dport 445 accept
|
||
icmp type echo-request accept
|
||
tcp dport 25 accept
|
||
tcp dport 587 accept
|
||
ct state established,related accept
|
||
}
|
||
}
|
||
EOF
|
||
|
||
# Activer et recharger nftables
|
||
sudo systemctl enable nftables
|
||
sudo systemctl restart nftables
|
||
|
||
echo "[INFO] Règles nftables appliquées et sauvegardées dans /etc/nftables.conf"
|
||
echo "[INFO] Elles seront rechargées automatiquement au redémarrage."
|
||
🚀 Vérification après reboot
|
||
Redémarrez le serveur :
|
||
sudo reboot
|
||
Vérifiez que les règles sont bien présentes :
|
||
sudo nft list ruleset
|
||
👉 Voulez-vous que je vous ajoute aussi un mécanisme de “secours” (par ex. une tâche systemd qui supprime les règles après 5 minutes si vous perdez la connexion SSH) pour éviter de rester bloqué si une erreur se glisse dans le script ?
|
||
Vous avez dit :
|
||
peux-tu me créer une règle nftable pour bloquer uniquement le traffic http, https à l'exception du proxy (http://proxy.gmolab.net port 8080)
|
||
ChatGPT a dit :
|
||
Très bonne idée 👍
|
||
Vous voulez que tout le trafic HTTP(S) direct (ports 80 et 443) soit bloqué, sauf si c’est envoyé via votre proxy proxy.gmolab.net (port 8080).
|
||
|
||
🔹 Étapes
|
||
Résoudre l’IP du proxy proxy.gmolab.net.
|
||
Dans OUTPUT, ajouter une règle pour accepter uniquement le trafic vers cette IP sur le port 8080.
|
||
Bloquer explicitement tout le reste en 80/tcp et 443/tcp.
|
||
⚠️ Comme la politique par défaut de vos chaînes est déjà drop, il faut être attentif :
|
||
On ajoute une exception accept pour le proxy.
|
||
On ajoute un rejet clair pour tout trafic vers ports 80 et 443.
|
||
🔹 Exemple de règles nftables
|
||
# Résolution de proxy.gmolab.net en IP
|
||
define PROXY_IP = 192.0.2.123 # <-- remplacer par l'IP réelle
|
||
|
||
table inet filter {
|
||
chain output {
|
||
type filter hook output priority 0;
|
||
policy drop;
|
||
|
||
# Autoriser le proxy
|
||
ip daddr $PROXY_IP tcp dport 8080 accept
|
||
|
||
# Bloquer tout autre HTTP/HTTPS
|
||
tcp dport { 80, 443 } reject with icmpx type admin-prohibited
|
||
}
|
||
}
|
||
👉 Ici :
|
||
reject with icmpx type admin-prohibited envoie une réponse claire, mais vous pouvez utiliser drop si vous préférez un silence total.
|
||
🔹 Ajout dynamique dans votre script existant
|
||
Dans votre script, il suffit de rajouter après la partie proxy :
|
||
PROXY_IP=$(getent ahostsv4 proxy.gmolab.net | awk '{print $1; exit}')
|
||
|
||
# Autoriser le proxy
|
||
sudo nft add rule inet filter output ip daddr $PROXY_IP tcp dport 8080 accept
|
||
|
||
# Bloquer tout autre HTTP/HTTPS
|
||
sudo nft add rule inet filter output tcp dport {80,443} reject with icmpx type admin-prohibited
|
||
🚀 Vérifications
|
||
Test direct (doit échouer) :
|
||
curl -v http://example.com
|
||
curl -vk https://example.com
|
||
Test via proxy (doit passer) :
|
||
curl -v -x http://proxy.gmolab.net:8080 http://example.com
|
||
👉 Est-ce que vous voulez que j’intègre cette restriction HTTP/HTTPS directement dans le gros script complet (avec proxy, DNS, NTP, CIFS, SMTP, ping, persistance), ou préférez-vous garder une règle séparée que vous appliquez en complément ?
|
||
|
||
|
||
|
||
ChatGPT peut faire des erreurs. Envisagez de vérifier les informations importantes.
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
Aujourd'hui
|
||
Vous avez dit
|
||
peux-tu me créer une règle nftable pour bloquer uniquement le traffic http, https à l'exception du proxy (http://proxy.gmolab.net port 8080)
|
||
Copilote a dit
|
||
Bien sûr ! Voici comment tu peux créer une règle nftables qui bloque tout le trafic HTTP (port 80) et HTTPS (port 443), sauf celui qui passe par ton proxy spécifique sur proxy.gmolab.net via le port 8080.
|
||
🛡️ Objectif
|
||
Bloquer tout le trafic sortant vers les ports 80 (HTTP) et 443 (HTTPS)
|
||
Autoriser uniquement le trafic vers proxy.gmolab.net sur le port 8080
|
||
🧱 Exemple de configuration nftables
|
||
Bash
|
||
|
||
|
||
Copier
|
||
#!/usr/sbin/nft -f
|
||
|
||
table inet filter {
|
||
chain output {
|
||
type filter hook output priority 0; policy accept;
|
||
|
||
# Autoriser le trafic vers le proxy sur le port 8080
|
||
ip daddr proxy.gmolab.net tcp dport 8080 accept
|
||
|
||
# Bloquer le trafic HTTP (port 80)
|
||
tcp dport 80 drop
|
||
|
||
# Bloquer le trafic HTTPS (port 443)
|
||
tcp dport 443 drop
|
||
}
|
||
}
|
||
⚠️ Remarques importantes
|
||
proxy.gmolab.net doit être résolu en adresse IP pour que la règle fonctionne correctement. nftables ne résout pas les noms DNS dynamiquement.
|
||
Tu peux obtenir l'IP avec :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
dig +short proxy.gmolab.net
|
||
Et remplacer ip daddr proxy.gmolab.net par l'adresse IP obtenue, par exemple :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
ip daddr 192.0.2.123 tcp dport 8080 accept
|
||
Si le proxy utilise IPv6, tu devras adapter avec ip6 daddr.
|
||
Assure-toi que le trafic passe bien par ce proxy (via configuration du navigateur ou des variables d'environnement comme http_proxy).
|
||
Souhaites-tu que je t'aide à automatiser la résolution DNS dans le script ou à tester la règle sur ton système ?
|
||
|
||
|
||
|
||
|
||
Modifier dans une page
|
||
Vous avez dit
|
||
La même chose mais avec firewalld
|
||
Copilote a dit
|
||
Très bien ! Voici comment tu peux configurer firewalld pour bloquer tout le trafic HTTP (port 80) et HTTPS (port 443), sauf celui qui passe par ton proxy spécifique proxy.gmolab.net sur le port 8080.
|
||
🔧 Étapes pour configurer firewalld
|
||
1. 🧠 Résoudre l'adresse IP du proxy
|
||
Firewalld ne gère pas les noms DNS dans les règles, donc tu dois d'abord obtenir l'adresse IP du proxy :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
dig +short proxy.gmolab.net
|
||
Disons que l'IP retournée est 192.0.2.123 (remplace par la vraie IP).
|
||
2. 🔥 Ajouter une zone personnalisée (optionnel mais recommandé)
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo firewall-cmd --permanent --new-zone=proxyzone
|
||
sudo firewall-cmd --permanent --zone=proxyzone --add-rich-rule='rule family="ipv4" destination address="192.0.2.123" port port="8080" protocol="tcp" accept'
|
||
3. 🚫 Bloquer HTTP et HTTPS dans la zone par défaut (souvent public)
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo firewall-cmd --permanent --zone=public --add-rich-rule='rule family="ipv4" port port="80" protocol="tcp" drop'
|
||
sudo firewall-cmd --permanent --zone=public --add-rich-rule='rule family="ipv4" port port="443" protocol="tcp" drop'
|
||
4. 🔁 Recharger firewalld
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo firewall-cmd --reload
|
||
✅ Résultat
|
||
Tout le trafic HTTP/HTTPS est bloqué
|
||
Seul le trafic vers proxy.gmolab.net:8080 est autorisé
|
||
Si tu veux que je t'aide à automatiser ça dans un script ou à gérer les cas où l'IP du proxy change, je peux te proposer une solution avec mise à jour dynamique. Tu veux aller plus loin ?
|
||
|
||
|
||
|
||
|
||
Modifier dans une page
|
||
Vous avez dit
|
||
oui
|
||
Copilote a dit
|
||
Parfait ! Voici comment automatiser la gestion du proxy dans firewalld, même si l'adresse IP de proxy.gmolab.net change régulièrement.
|
||
🛠️ Objectif : Script dynamique pour firewalld
|
||
Ce script :
|
||
Résout l'IP actuelle du proxy
|
||
Supprime les anciennes règles
|
||
Ajoute une règle autorisant uniquement le trafic vers le proxy sur le port 8080
|
||
Bloque tout le reste du trafic HTTP/HTTPS
|
||
🐚 Script Bash
|
||
Bash
|
||
|
||
|
||
Copier
|
||
#!/bin/bash
|
||
|
||
# Nom du domaine du proxy
|
||
PROXY_DOMAIN="proxy.gmolab.net"
|
||
PROXY_PORT="8080"
|
||
ZONE="public"
|
||
|
||
# Résolution DNS
|
||
PROXY_IP=$(dig +short "$PROXY_DOMAIN" | grep -Eo '^[0-9\.]+$' | head -n 1)
|
||
|
||
if [ -z "$PROXY_IP" ]; then
|
||
echo "❌ Impossible de résoudre l'adresse IP du proxy."
|
||
exit 1
|
||
fi
|
||
|
||
echo "✅ Proxy IP résolue : $PROXY_IP"
|
||
|
||
# Supprimer les anciennes règles (si existantes)
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv4' destination address='$PROXY_IP' port port='$PROXY_PORT' protocol='tcp' accept" 2>/dev/null
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv4' port port='80' protocol='tcp' drop" 2>/dev/null
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv4' port port='443' protocol='tcp' drop" 2>/dev/null
|
||
|
||
# Ajouter les nouvelles règles
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' destination address='$PROXY_IP' port port='$PROXY_PORT' protocol='tcp' accept"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' port port='80' protocol='tcp' drop"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' port port='443' protocol='tcp' drop"
|
||
|
||
# Recharger firewalld
|
||
firewall-cmd --reload
|
||
|
||
echo "✅ Règles mises à jour avec succès."
|
||
🧠 Astuce bonus
|
||
Tu peux automatiser ce script avec un cron job pour qu'il s'exécute régulièrement et adapte les règles si l'IP du proxy change :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
crontab -e
|
||
Ajoute par exemple :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
0 * * * * /chemin/vers/le/script.sh
|
||
Cela le lancera toutes les heures.
|
||
Souhaites-tu que je t'aide à le transformer en service systemd ou à le sécuriser davantage ?
|
||
|
||
|
||
|
||
|
||
Modifier dans une page
|
||
Vous avez dit
|
||
peux-tu me créer une règle nftable pour bloquer uniquement le traffic sortant http, https à l'exception du proxy (http://proxy.gmolab.net port 8080)
|
||
Copilote a dit
|
||
Absolument ! Voici comment créer une règle nftables qui bloque tout le trafic sortant HTTP (port 80) et HTTPS (port 443), sauf vers le proxy proxy.gmolab.net sur le port 8080.
|
||
🧱 Étapes de configuration avec nftables
|
||
1. 🔍 Résoudre l'adresse IP du proxy
|
||
nftables ne gère pas les noms DNS dynamiquement, donc tu dois d'abord obtenir l'IP du proxy :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
dig +short proxy.gmolab.net
|
||
Disons que l'IP retournée est 192.0.2.123 (remplace par la vraie IP).
|
||
2. 🛡️ Exemple de configuration nftables
|
||
Bash
|
||
|
||
|
||
Copier
|
||
#!/usr/sbin/nft -f
|
||
|
||
table inet filter {
|
||
chain output {
|
||
type filter hook output priority 0; policy accept;
|
||
|
||
# ✅ Autoriser le trafic vers le proxy sur le port 8080
|
||
ip daddr 192.0.2.123 tcp dport 8080 accept
|
||
|
||
# ❌ Bloquer le trafic HTTP (port 80)
|
||
tcp dport 80 drop
|
||
|
||
# ❌ Bloquer le trafic HTTPS (port 443)
|
||
tcp dport 443 drop
|
||
}
|
||
}
|
||
3. 💾 Sauvegarder et appliquer
|
||
Enregistre ce fichier, par exemple sous /etc/nftables.conf, puis active-le :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo nft -f /etc/nftables.conf
|
||
Et pour que ça persiste au redémarrage :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo systemctl enable nftables
|
||
🧠 Astuce : mise à jour automatique de l'IP
|
||
Si l'IP du proxy change, tu peux automatiser la mise à jour avec un petit script :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
#!/bin/bash
|
||
|
||
PROXY_DOMAIN="proxy.gmolab.net"
|
||
PROXY_PORT="8080"
|
||
PROXY_IP=$(dig +short "$PROXY_DOMAIN" | grep -Eo '^[0-9\.]+$' | head -n 1)
|
||
|
||
if [ -z "$PROXY_IP" ]; then
|
||
echo "Erreur : impossible de résoudre l'IP du proxy."
|
||
exit 1
|
||
fi
|
||
|
||
cat <<EOF > /etc/nftables.conf
|
||
table inet filter {
|
||
chain output {
|
||
type filter hook output priority 0; policy accept;
|
||
|
||
ip daddr $PROXY_IP tcp dport $PROXY_PORT accept
|
||
tcp dport 80 drop
|
||
tcp dport 443 drop
|
||
}
|
||
}
|
||
EOF
|
||
|
||
nft -f /etc/nftables.conf
|
||
Tu peux ensuite l'exécuter régulièrement via cron pour garder la règle à jour.
|
||
Souhaites-tu que je t'aide à intégrer ce script dans un service systemd ou à le sécuriser davantage ?
|
||
|
||
|
||
|
||
|
||
Modifier dans une page
|
||
Vous avez dit
|
||
peux-tu me créer une règle firewalld pour bloquer uniquement le traffic sortant http, https à l'exception du proxy (http://proxy.gmolab.net port 8080)
|
||
Copilote a dit
|
||
Bien sûr ! Voici comment configurer firewalld pour bloquer tout le trafic sortant HTTP (port 80) et HTTPS (port 443), sauf vers le proxy proxy.gmolab.net sur le port 8080.
|
||
🧠 Étape 1 : Résolution de l'adresse IP du proxy
|
||
Firewalld ne gère pas les noms DNS dans les règles, donc tu dois d'abord obtenir l'IP du proxy :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
dig +short proxy.gmolab.net
|
||
Disons que l'IP retournée est 192.0.2.123 (remplace-la par la vraie IP).
|
||
🔧 Étape 2 : Ajouter les règles avec firewall-cmd
|
||
🔓 Autoriser le trafic vers le proxy
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv4" destination address="192.0.2.123" port port="8080" protocol="tcp" accept'
|
||
🚫 Bloquer le trafic HTTP et HTTPS sortant
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv4" port port="80" protocol="tcp" drop'
|
||
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv4" port port="443" protocol="tcp" drop'
|
||
🔁 Recharger firewalld
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo firewall-cmd --reload
|
||
🛠️ Automatiser la mise à jour de l'IP du proxy
|
||
Si l'IP du proxy change, tu peux créer un script pour mettre à jour les règles dynamiquement :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
#!/bin/bash
|
||
|
||
PROXY_DOMAIN="proxy.gmolab.net"
|
||
PROXY_PORT="8080"
|
||
ZONE="public"
|
||
|
||
PROXY_IP=$(dig +short "$PROXY_DOMAIN" | grep -Eo '^[0-9\.]+$' | head -n 1)
|
||
|
||
if [ -z "$PROXY_IP" ]; then
|
||
echo "❌ Impossible de résoudre l'IP du proxy."
|
||
exit 1
|
||
fi
|
||
|
||
# Supprimer les anciennes règles
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv4' destination address='$PROXY_IP' port port='$PROXY_PORT' protocol='tcp' accept" 2>/dev/null
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv4' port port='80' protocol='tcp' drop" 2>/dev/null
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv4' port port='443' protocol='tcp' drop" 2>/dev/null
|
||
|
||
# Ajouter les nouvelles règles
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' destination address='$PROXY_IP' port port='$PROXY_PORT' protocol='tcp' accept"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' port port='80' protocol='tcp' drop"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' port port='443' protocol='tcp' drop"
|
||
|
||
firewall-cmd --reload
|
||
Tu peux ensuite l'exécuter régulièrement via cron pour garder les règles à jour.
|
||
Souhaites-tu que je t'aide à transformer ce script en service systemd ou à le rendre plus robuste avec des logs et des vérifications réseau ?
|
||
|
||
|
||
|
||
|
||
Modifier dans une page
|
||
Vous avez dit
|
||
peux-tu me créer une règle firewalld pour bloquer uniquement le traffic sortant http, https ipv4 et ipv6 à l'exception du proxy (http://proxy.gmolab.net port 8080)
|
||
Copilote a dit
|
||
Bien sûr ! Voici comment configurer firewalld pour bloquer tout le trafic sortant HTTP (port 80) et HTTPS (port 443) en IPv4 et IPv6, tout en autorisant uniquement les connexions vers le proxy proxy.gmolab.net sur le port 8080.
|
||
🧠 Étape 1 : Résolution des adresses IP du proxy
|
||
Firewalld ne gère pas les noms DNS dans les règles, donc tu dois d'abord obtenir les adresses IP (IPv4 et IPv6) du proxy :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
dig +short proxy.gmolab.net
|
||
dig +short AAAA proxy.gmolab.net
|
||
Disons que tu obtiens :
|
||
IPv4 : 192.0.2.123
|
||
IPv6 : 2001:db8::123
|
||
🔧 Étape 2 : Ajouter les règles avec firewall-cmd
|
||
🔓 Autoriser le trafic vers le proxy (IPv4 et IPv6)
|
||
Bash
|
||
|
||
|
||
Copier
|
||
# IPv4
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv4" destination address="192.0.2.123" port port="8080" protocol="tcp" accept'
|
||
|
||
# IPv6
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv6" destination address="2001:db8::123" port port="8080" protocol="tcp" accept'
|
||
🚫 Bloquer le trafic HTTP/HTTPS sortant (IPv4 et IPv6)
|
||
Bash
|
||
|
||
|
||
Copier
|
||
# IPv4
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv4" port port="80" protocol="tcp" drop'
|
||
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv4" port port="443" protocol="tcp" drop'
|
||
|
||
# IPv6
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv6" port port="80" protocol="tcp" drop'
|
||
|
||
sudo firewall-cmd --permanent --zone=public \
|
||
--add-rich-rule='rule family="ipv6" port port="443" protocol="tcp" drop'
|
||
🔁 Recharger firewalld
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo firewall-cmd --reload
|
||
🛠️ Astuce : Script dynamique si l'IP du proxy change
|
||
Tu peux automatiser la mise à jour des règles avec un script qui résout les IP et les applique :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
#!/bin/bash
|
||
|
||
ZONE="public"
|
||
PROXY_DOMAIN="proxy.gmolab.net"
|
||
PROXY_PORT="8080"
|
||
|
||
IPV4=$(dig +short "$PROXY_DOMAIN" | grep -Eo '^[0-9\.]+$' | head -n 1)
|
||
IPV6=$(dig +short AAAA "$PROXY_DOMAIN" | grep -Eo '^[0-9a-fA-F:]+$' | head -n 1)
|
||
|
||
# Supprimer anciennes règles (optionnel)
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv4' destination address='$IPV4' port port='$PROXY_PORT' protocol='tcp' accept" 2>/dev/null
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv6' destination address='$IPV6' port port='$PROXY_PORT' protocol='tcp' accept" 2>/dev/null
|
||
|
||
# Ajouter nouvelles règles
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' destination address='$IPV4' port port='$PROXY_PORT' protocol='tcp' accept"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv6' destination address='$IPV6' port port='$PROXY_PORT' protocol='tcp' accept"
|
||
|
||
# Bloquer HTTP/HTTPS si pas déjà fait
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' port port='80' protocol='tcp' drop"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' port port='443' protocol='tcp' drop"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv6' port port='80' protocol='tcp' drop"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv6' port port='443' protocol='tcp' drop"
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
# Activer la zone par défaut (ex. public)
|
||
firewall-cmd --set-default-zone=public
|
||
|
||
# Bloquer les ports sortants 80 et 443 (IPv4 et IPv6)
|
||
firewall-cmd --permanent --add-rich-rule='rule family=ipv4 port port=80 protocol=tcp drop'
|
||
firewall-cmd --permanent --add-rich-rule='rule family=ipv4 port port=443 protocol=tcp drop'
|
||
firewall-cmd --permanent --add-rich-rule='rule family=ipv6 port port=80 protocol=tcp drop'
|
||
firewall-cmd --permanent --add-rich-rule='rule family=ipv6 port port=443 protocol=tcp drop'
|
||
|
||
# Autoriser l'accès au proxy (port 8080, TCP, IPv4/IPv6)
|
||
firewall-cmd --permanent --add-rich-rule='rule family=ipv4 destination address=172.31.10.23 port port=8080 protocol=tcp accept'
|
||
#firewall-cmd --permanent --add-rich-rule='rule family=ipv6 destination address=IPV6_PROXY port port=8080 protocol=tcp accept'
|
||
|
||
# Recharger firewalld
|
||
firewall-cmd --reload
|
||
|
||
firewall-cmd --reload
|
||
Tu peux ensuite l'exécuter régulièrement via cron ou le transformer en service systemd pour qu'il s'adapte automatiquement.
|
||
Souhaites-tu que je t'aide à le intégrer dans ton système ou à le rendre encore plus robuste avec des logs et des vérifications réseau ?
|
||
|
||
|
||
|
||
|
||
Modifier dans une page
|
||
Vous avez dit
|
||
oui
|
||
Copilote a dit
|
||
Parfait, allons plus loin et transformons ce script en un service systemd pour qu'il s'exécute automatiquement au démarrage et puisse être relancé manuellement ou programmé via cron si nécessaire.
|
||
🧩 Étape 1 : Créer le script dynamique
|
||
Crée un fichier script, par exemple :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo nano /usr/local/bin/update-firewalld-proxy.sh
|
||
Colle ceci dedans :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
#!/bin/bash
|
||
|
||
ZONE="public"
|
||
PROXY_DOMAIN="proxy.gmolab.net"
|
||
PROXY_PORT="8080"
|
||
|
||
IPV4=$(dig +short "$PROXY_DOMAIN" | grep -Eo '^[0-9\.]+$' | head -n 1)
|
||
IPV6=$(dig +short AAAA "$PROXY_DOMAIN" | grep -Eo '^[0-9a-fA-F:]+$' | head -n 1)
|
||
|
||
if [ -z "$IPV4" ] && [ -z "$IPV6" ]; then
|
||
echo "❌ Impossible de résoudre l'IP du proxy."
|
||
exit 1
|
||
fi
|
||
|
||
# Supprimer anciennes règles
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv4' destination address='$IPV4' port port='$PROXY_PORT' protocol='tcp' accept" 2>/dev/null
|
||
firewall-cmd --zone=$ZONE --remove-rich-rule="rule family='ipv6' destination address='$IPV6' port port='$PROXY_PORT' protocol='tcp' accept" 2>/dev/null
|
||
|
||
# Ajouter nouvelles règles
|
||
[ -n "$IPV4" ] && firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' destination address='$IPV4' port port='$PROXY_PORT' protocol='tcp' accept"
|
||
[ -n "$IPV6" ] && firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv6' destination address='$IPV6' port port='$PROXY_PORT' protocol='tcp' accept"
|
||
|
||
# Bloquer HTTP/HTTPS (si pas déjà fait)
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' port port='80' protocol='tcp' drop"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv4' port port='443' protocol='tcp' drop"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv6' port port='80' protocol='tcp' drop"
|
||
firewall-cmd --permanent --zone=$ZONE --add-rich-rule="rule family='ipv6' port port='443' protocol='tcp' drop"
|
||
|
||
firewall-cmd --reload
|
||
Rends-le exécutable :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo chmod +x /usr/local/bin/update-firewalld-proxy.sh
|
||
⚙️ Étape 2 : Créer le service systemd
|
||
Crée le fichier de service :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo nano /etc/systemd/system/update-firewalld-proxy.service
|
||
Ajoute ceci :
|
||
Ini
|
||
|
||
|
||
Copier
|
||
[Unit]
|
||
Description=Met à jour les règles firewalld pour autoriser uniquement le proxy
|
||
After=network-online.target firewalld.service
|
||
Wants=network-online.target
|
||
|
||
[Service]
|
||
Type=oneshot
|
||
ExecStart=/usr/local/bin/update-firewalld-proxy.sh
|
||
|
||
[Install]
|
||
WantedBy=multi-user.target
|
||
🚀 Étape 3 : Activer et tester le service
|
||
Active le service pour qu'il s'exécute au démarrage :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo systemctl enable update-firewalld-proxy.service
|
||
Et lance-le manuellement pour tester :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo systemctl start update-firewalld-proxy.service
|
||
Tu peux vérifier son statut avec :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo systemctl status update-firewalld-proxy.service
|
||
🕒 Bonus : exécution régulière avec cron
|
||
Ajoute une tâche cron pour le relancer toutes les heures :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
sudo crontab -e
|
||
Ajoute :
|
||
Bash
|
||
|
||
|
||
Copier
|
||
0 * * * * /usr/local/bin/update-firewalld-proxy.sh
|
||
Souhaites-tu que je t'aide à ajouter des logs, des alertes en cas d'échec, ou à intégrer ça dans une interface graphique ?
|
||
|
||
|
||
|
||
|
||
|
||
Modifier dans une page
|
||
|
||
|
||
|
||
|
||
Réponse rapide
|
||
|
||
|
||
|
||
|
||
Se connecter
|
||
|