Travaux sur le script de pare-feu simplifié du Wiki

Salut,
Suite aux remarques de PascalHambourg, j’ai (péniblement) fais quelques modifications sur le script de pare-feu simplifié qui se trouve sur le Wiki.

#!/bin/sh
 
### BEGIN INIT INFO
# Provides:           mon_parefeu
# Required-Start:     $local_fs 
# Should-Start:
# Required-Stop:      $local_fs 
# Should-Stop:
# X-Start-Before:     $network
# X-Stop-After:       $network
# Default-Start:      S
# Default-Stop:       0 6
# Short-description:  Configure le parefeu
# Description:        Met en place les règles iptables.
### END INIT INFO
 
#------------------------Explications----------------------------------#
#
# Défauts :
# - Cette configuration s'applique à toutes les interfaces réseau.
#   Si vous voulez restreindre cela à une interface donnée,
#   décommentez la ligne suivante #IFACE="-i eth0"
#
# - Par défaut, le script autorise tout en sortie. 
#   Pour changer ce comportement veuillez indiquer les numéros
#   de port en question dans les variables
#	         $REMOTE_TCP_SERVICES
#   et/ou    $REMOTE_UDP_SERVICES
#
# - Pour configurer une machine routeur, 
#   changez la valeur de la variable
#   ISROUTERNAT à true, ainsi que 
#   les interfaces ethx et ethy selon votre configuration
#         ethx correspond à l'interface du LAN
#         ethy correspond à l'interface reliée à la truc-box
#
# description: Active/Désactive le pare-feu au démarrage
#
#------------------------VARIABLES-------------------------------------#

readonly IPTABLES=/sbin/iptables

. /lib/lsb/init-functions

# Services que le système offrira au réseau, à séparer avec des espaces
# ftp : 21, ssh : 22, serveur web : 80, cups : 631, jabber : 5222
TCP_SERVICES="" 
UDP_SERVICES=""

# Services que le système utilisera du réseau
# (défaut : autorise tout en sortie)
REMOTE_TCP_SERVICES="" 
REMOTE_UDP_SERVICES="" 
 
# Pour une machine faisant office de routeur avec NAT, changer la valeur de la variable ISROUTERNAT à "true".
ISROUTERNAT=false

# ethx correspond à l'interface du LAN
# ethy correspond à l'interface reliée à la truc-box
ethx="eth1"
ethy="eth0"

# Décommentez la ligne suivante et ajustez le nom de l'interface pour restreindre le trafic entrant à cette interface particulière.
#IFACE="-i eth0"

#----------------------------------------------------------------------#
 if ! [ -x $IPTABLES ]; then  
	exit 0
fi
#----------------------------FONCTIONS---------------------------------#
fw_start () {
 
# Vidage
	fw_clear
	# Parefeu - Suppression des règles
 
# Interdictions
	$IPTABLES -t filter -P INPUT DROP
	$IPTABLES -t filter -P FORWARD DROP
	$IPTABLES -t filter -P OUTPUT DROP
 
	# Parefeu - interdictions générales établies
 
# Loopback
	$IPTABLES -t filter -A INPUT -i lo -j ACCEPT
 
# Trafic d'entrée :
	$IPTABLES -t filter -A INPUT ${IFACE} -m state --state ESTABLISHED,RELATED -j ACCEPT
 
# Limitation de la taille et de la fréquence des pings acceptés
        $IPTABLES -A INPUT ${IFACE} -p icmp --icmp-type echo-request -m limit --limit 10/second -m length --length 8:2000 -j ACCEPT

# Sortie autorisée, si aucun port autorisé en sortie n'est défini
        if [ -z "$REMOTE_TCP_SERVICES"] && [ -z "$REMOTE_UDP_SERVICES" ]; then
           $IPTABLES -t filter -A OUTPUT -j ACCEPT
        else
           $IPTABLES -t filter -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

           # Services à autoriser en sortie
           for PORT in $REMOTE_TCP_SERVICES; do
             $IPTABLES -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT
           done

           for PORT in $REMOTE_UDP_SERVICES; do
             $IPTABLES -A OUTPUT -p udp --dport ${PORT} -j ACCEPT
           done
        fi

# Services à autoriser en entrée
	for PORT in $TCP_SERVICES; do
		$IPTABLES -A INPUT ${IFACE} -p tcp --dport ${PORT} -j ACCEPT
	done
	for PORT in $UDP_SERVICES; do
		$IPTABLES -A INPUT ${IFACE} -p udp --dport ${PORT} -j ACCEPT
	done

# NAT 
        if $ISROUTERNAT ; then
		$IPTABLES -A INPUT -i $ethx -j ACCEPT
		$IPTABLES -A FORWARD -i $ethy -o $ethx -m state --state RELATED,ESTABLISHED -j ACCEPT
		$IPTABLES -A FORWARD -i $ethx -o $ethy -j ACCEPT
		$IPTABLES -t nat -A POSTROUTING -o $ethy -j MASQUERADE
 		# Parefeu - Routeur avec NAT
	fi
 
# Toutes les autres connexions sont enregistrées dans syslog
	#$IPTABLES -t filter -A OUTPUT -j LOG
	$IPTABLES -t filter -A INPUT -j LOG --log-level=4
 
	# Parefeu - Logging
}
 
fw_save () {
	#$IPTABLES -F
	#$IPTABLES -t nat -F
	#$IPTABLES -t mangle -F
	#$IPTABLES -P INPUT DROP
	#$IPTABLES -P FORWARD DROP
	#$IPTABLES -P OUTPUT ACCEPT
	iptables-save > /etc/firewall
}
 
fw_clear () {
	$IPTABLES -t filter -F
	$IPTABLES -t nat -F
	$IPTABLES -t mangle -F
	$IPTABLES -t raw -F
	$IPTABLES -t filter -P INPUT ACCEPT
	$IPTABLES -t filter -P OUTPUT ACCEPT
	$IPTABLES -t filter -P FORWARD ACCEPT
	$IPTABLES -t nat -P PREROUTING ACCEPT
	$IPTABLES -t nat -P POSTROUTING ACCEPT
	$IPTABLES -t nat -P OUTPUT ACCEPT
# Décommentez si votre noyau est > à 2.6.36
#        $IPTABLES -t nat -P INTPUT ACCEPT
	$IPTABLES -t mangle -P PREROUTING ACCEPT
	$IPTABLES -t mangle -P OUTPUT ACCEPT
	$IPTABLES -t mangle -P POSTROUTING ACCEPT
	$IPTABLES -t mangle -P FORWARD ACCEPT
	$IPTABLES -t mangle -P INPUT ACCEPT
	$IPTABLES -t raw -P OUTPUT ACCEPT
	$IPTABLES -t raw -P PREROUTING ACCEPT
	$IPTABLES -F
}
 
fw_status () {
	$IPTABLES -L --line-numbers
}
 
#----------------------------------------------------------------------#
 
case "$1" in
	start|restart)
		log_daemon_msg "Starting firewall.."
 		fw_start
		log_end_msg $?
 	;;
	save)
		log_daemon_msg "Saving firewall.."
 		fw_save
		log_end_msg $?
 	;;
	clean)
 		log_daemon_msg "Clearing firewall rules.."
 		fw_clear
		log_end_msg $?
 	;;
	status)
		log_daemon_msg "Firewall status"
		fw_status
	;;
	*)
 		log_action_msg "Usage $0 {start|save|restart|clean|status}"
 		exit 1
 	;;
esac
exit 0

Il reste au moins 2 choses que je n’arrive pas à faire:

  1. Tester la version du noyau (si c’est > 2.6.36 appliquer la règle suivante: $IPTABLES -t nat -P INTPUT ACCEPT
    Mais je ne m’en sors pas… Je n’arrive à sortir que les 3 premier chiffres de la version du noyau…

kver=$(uname -r|cut -d\- -f1|tr -d '.'| tr -d '[A-Z][a-z]') if [ 263 -ge $kver ] ; then echo "Kernel < 2.6.36" else echo "Kernel > 2.6.36" fi

  1. ici:

for PORT in $REMOTE_TCP_SERVICES; do $IPTABLES -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT done for PORT in $REMOTE_UDP_SERVICES; do $IPTABLES -A OUTPUT -p udp --dport ${PORT} -j ACCEPT done $IPTABLES -t filter -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPTPascalHambourg me propose d’utiliser else, mais je ne vois pas ou…

En passant je proposerais bien de supprimer le “logging” (ou au moins le commenter par défaut) ça remplit des lignes et des lignes pour pas grand chose… Qui regarde ses logs iptables en permanence?

a) Il manque ${IFACE} dans la ligne pour limiter le ping.
b) Le “else” sert à exécuter le second bloc seulement si les variables sont non vides :

[code]# Sortie autorisée, si aucun port autorisé en sortie n’est défini
if [ -z “$REMOTE_TCP_SERVICES”] && [ -z “$REMOTE_UDP_SERVICES” ]; then
$IPTABLES -t filter -A OUTPUT -j ACCEPT
else
$IPTABLES -t filter -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

       # Services à autoriser en sortie
       for PORT in $REMOTE_TCP_SERVICES; do
         $IPTABLES -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT
       done

       for PORT in $REMOTE_UDP_SERVICES; do
         $IPTABLES -A OUTPUT -p udp --dport ${PORT} -j ACCEPT
       done
    fi

[/code]
c) Je suis nul en programmation de shell, mais il existe de nombreux exemples plus ou moins compliqués, rechercher “shell compare versions”. Par contre c’est >= 2.6.36, pas >.

Réponse pour les logs :
Ça peut être intéressant si on arrive pas à trouver d’où vient une erreur ou une anomalie.
En fait, si c’est une question de place occupée sur le DD, tu peux proposer de décommenter à la demande, avec une ligne explicative en début de ton script. Bien sûr, dans ce cas, les logs “passés” ne seront pas là, seuls les logs “à venir”. Tu peux ajouter un mini script qui fasse ça de façon simple.
MAIS qui a besoin de place sur un DD de nos jours avec des trucs de 3 To :wink:

Salut,

@PascalHambourg:

a) Ok, c’est fait
b) Merci! :023
c) J’y suis presque mais je suis emmerdé avec les points et tirets… 2.6.36 3.10-1…
Si je ne prend que les trois premiers nombres, il me manque une variable et je ne peux comparer 310 avec 2636.
Je continue à chercher!

@Ricardo:
Oui c’est exactement ce que je propose (je mettrais une variable “oui ou non” en début de script pour éviter d’avoir à toucher plus bas)

Merci à vous.

Salut,
J’ai écrit un petit test qui devrait faire l’affaire (en fait j’ai simplement ajouté un 0 aux noyaux qui contiennent une version à 3 chiffres pour que ce soit comparable avec le 3.6.36 qui en a quatre…).

[code]#!/bin/sh
k=$(uname -r|cut -d- -f1|tr -d ‘.’| tr -d ‘[A-Z][a-z]’)
echo "$k"
count=$(echo -n “$k” | wc -c)
echo “$count"
if [ $count -ge 3 ] ; then
k1=“0"
kver=”$k$k1"
else
kver=”$k"
fi

echo “$kver”

if [ 2636 -ge $kver ] ; then
echo "Kernel < 2.6.36"
else
echo "Kernel >= 2.6.36"
fi[/code]

Mais je n’ai pas de machine avec un noyau en dessous de 2.6.36…
Est-ce quelqu’un peux tester, j’aimerais bien être sur de mon coup.

Merci.

Salut,
J’ai galéré un peu plus que prévu, je me suis aperçu que le version des kernels pouvaient avoir jusqu’a 6 caractères…
Bref, j’ai trouvé comment faire, mais j’aimerais vraiment que vous jetiez un oeil avant que je mette sur le Wiki…

[code]#!/bin/sh

BEGIN INIT INFO

Provides: mon_parefeu

Required-Start: $local_fs

Should-Start:

Required-Stop: $local_fs

Should-Stop:

X-Start-Before: $network

X-Stop-After: $network

Default-Start: S

Default-Stop: 0 6

Short-description: Configure le parefeu

Description: Met en place les règles iptables.

END INIT INFO

#------------------------Explications----------------------------------#

Défauts :

- Cette configuration s’applique à toutes les interfaces réseau.

Si vous voulez restreindre cela à une interface donnée,

dé-commentez la ligne #IFACE="-i eth0" (dans la section variables)

- Par défaut, le script autorise tout en sortie.

Pour changer ce comportement veuillez indiquer les numéros

de port en question dans les variables

$REMOTE_TCP_SERVICES

et/ou $REMOTE_UDP_SERVICES

- Pour configurer une machine routeur,

changez la valeur de la variable

ISROUTERNAT à true, ainsi que

les interfaces ethx et ethy selon votre configuration

ethx correspond à l’interface du LAN

ethy correspond à l’interface reliée à la truc-box

description: Active/Désactive le pare-feu au démarrage

#------------------------VARIABLES-------------------------------------#

readonly IPTABLES=/sbin/iptables
. /lib/lsb/init-functions

Services que le système offrira au réseau, à séparer avec des espaces

ftp : 21, ssh : 22, serveur web : 80, cups : 631, jabber : 5222

TCP_SERVICES="“
UDP_SERVICES=”"

Services que le système utilisera du réseau

(défaut : autorise tout en sortie)

REMOTE_TCP_SERVICES="“
REMOTE_UDP_SERVICES=”"

Pour une machine faisant office de routeur avec NAT, changer la valeur de la variable ISROUTERNAT à “true”.

ISROUTERNAT=false

ethx correspond à l’interface du LAN

ethy correspond à l’interface reliée à la truc-box

ethx="eth1"
ethy=“eth0”

Décommentez la ligne suivante et ajustez le nom de l’interface pour restreindre le trafic entrant à cette interface particulière.

#IFACE="-i eth0"

Récupération de la version du noyau et test si >= à 2.6.36

k=$(uname -r|cut -d- -f1|tr -d ‘.’| tr -d ‘[A-Z][a-z]’)
count=$(echo -n “$k” | wc -c)
if [ $count -ge 4 ] ; then
kver=$( echo $k | cut -c -4 )
else
k1=“0”; kver="$k$k1"
fi

if [ $kver -ge 2636 ] ; then
k2636=1
else
k2636=0
fi

Activation des logs (mettre à true pour activer)

LOGGING=false

#----------------------------------------------------------------------#

NE RIEN MODIFIER APRES CETTE LIGNE.

#----------------------------------------------------------------------#
if ! [ -x $IPTABLES ]; then
exit 0
fi
#----------------------------FONCTIONS---------------------------------#
fw_start () {

Vidage

fw_clear

Parefeu - Suppression des règles

Interdictions

$IPTABLES -t filter -P INPUT DROP
$IPTABLES -t filter -P FORWARD DROP
$IPTABLES -t filter -P OUTPUT DROP

Parefeu - interdictions générales établies

Loopback

$IPTABLES -t filter -A INPUT -i lo -j ACCEPT

Trafic d’entrée :

$IPTABLES -t filter -A INPUT ${IFACE} -m state --state ESTABLISHED,RELATED -j ACCEPT

Limitation de la taille et de la fréquence des pings acceptés

    $IPTABLES -A INPUT ${IFACE} -p icmp --icmp-type echo-request -m limit --limit 10/second -m length --length 8:2000 -j ACCEPT

Sortie autorisée, si aucun port autorisé en sortie n’est défini

    if [ -z "$REMOTE_TCP_SERVICES"] && [ -z "$REMOTE_UDP_SERVICES" ]; then
       $IPTABLES -t filter -A OUTPUT -j ACCEPT
    else
       $IPTABLES -t filter -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

       # Services à autoriser en sortie
       for PORT in $REMOTE_TCP_SERVICES; do
         $IPTABLES -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT
       done

       for PORT in $REMOTE_UDP_SERVICES; do
         $IPTABLES -A OUTPUT -p udp --dport ${PORT} -j ACCEPT
       done
    fi

Services à autoriser en entrée

for PORT in $TCP_SERVICES; do
$IPTABLES -A INPUT ${IFACE} -p tcp --dport ${PORT} -j ACCEPT
done
for PORT in $UDP_SERVICES; do
$IPTABLES -A INPUT ${IFACE} -p udp --dport ${PORT} -j ACCEPT
done

NAT

    if $ISROUTERNAT ; then
  $IPTABLES -A INPUT -i $ethx -j ACCEPT
  $IPTABLES -A FORWARD -i $ethy -o $ethx -m state --state RELATED,ESTABLISHED -j ACCEPT
  $IPTABLES -A FORWARD -i $ethx -o $ethy -j ACCEPT
  $IPTABLES -t nat -A POSTROUTING -o $ethy -j MASQUERADE
   # Parefeu - Routeur avec NAT

fi

Toutes les autres connexions sont enregistrées dans syslog

if $LOGGING ; then
$IPTABLES -t filter -A INPUT -j LOG --log-level=4

Parefeu - Logging

fi

}

fw_save () {
#$IPTABLES -F
#$IPTABLES -t nat -F
#$IPTABLES -t mangle -F
#$IPTABLES -P INPUT DROP
#$IPTABLES -P FORWARD DROP
#$IPTABLES -P OUTPUT ACCEPT
iptables-save > /etc/firewall
}

fw_clear () {
$IPTABLES -t filter -F
$IPTABLES -t nat -F
$IPTABLES -t mangle -F
$IPTABLES -t raw -F
$IPTABLES -t filter -P INPUT ACCEPT
$IPTABLES -t filter -P OUTPUT ACCEPT
$IPTABLES -t filter -P FORWARD ACCEPT
$IPTABLES -t nat -P PREROUTING ACCEPT
$IPTABLES -t nat -P POSTROUTING ACCEPT
$IPTABLES -t nat -P OUTPUT ACCEPT
if [ $k2636 -eq 1 ] ; then
$IPTABLES -t nat -P INPUT ACCEPT
fi
$IPTABLES -t mangle -P PREROUTING ACCEPT
$IPTABLES -t mangle -P OUTPUT ACCEPT
$IPTABLES -t mangle -P POSTROUTING ACCEPT
$IPTABLES -t mangle -P FORWARD ACCEPT
$IPTABLES -t mangle -P INPUT ACCEPT
$IPTABLES -t raw -P OUTPUT ACCEPT
$IPTABLES -t raw -P PREROUTING ACCEPT
$IPTABLES -F
}

fw_status () {
$IPTABLES -L --line-numbers
}

#----------------------------------------------------------------------#

case “$1” in
start|restart)
log_daemon_msg "Starting firewall…"
fw_start
log_end_msg $?
;;
save)
log_daemon_msg "Saving firewall…"
fw_save
log_end_msg $?
;;
clean)
log_daemon_msg "Clearing firewall rules…"
fw_clear
log_end_msg $?
;;
status)
log_daemon_msg "Firewall status"
fw_status
;;
*)
log_action_msg "Usage $0 {start|save|restart|clean|status}"
exit 1
;;
esac
exit 0[/code]

C’est très sympa d’avoir commencé le boulot! :slightly_smiling:
Après une lecture rapide, je n’ai pas détecté de problème particulier.

Un commentaire à propos de la variable IFACE. Si monsieur Pinpin copie/colle le script sans décommenter cette ligne, cela peut poser problème puisque la variable est alors restée commentée.

Je propose soit de laisser cette ligne décommentée, soit de mettre un simple test :

# Ajustez le nom de l'interface pour restreindre le trafic entrant à cette interface particulière. PAr exemple : IFACE="-i eth0" IFACE="" if [ -z $IFACE ] echo "Aucune interface spécifiée" exit 1 fi

EDIT : en fait, cela ne dérange pas la commande iptables, je me suis gourré. :blush:

Test réalisé sur un noyau 3.10-0.bpo.2-amd64 : aucune erreur à signaler pour l’instant.

Cependant, vous pourrez en dire plus que moi au regard des règles réellement appliquées :

[code]iptables -L
Chain INPUT (policy DROP)
target prot opt source destination
ACCEPT all – anywhere anywhere
ACCEPT all – anywhere anywhere state RELATED,ESTABLISHED
ACCEPT icmp – anywhere anywhere icmp echo-request limit: avg 10/sec burst 5 length 8:2000

Chain FORWARD (policy DROP)
target prot opt source destination

Chain OUTPUT (policy DROP)
target prot opt source destination
ACCEPT all – anywhere anywhere
[/code]

Salut,
Pour ce qui est de la règle dont tu parles, tu ne le verra que sur un iptables-save après un “service parefeu clean”.

[quote=“thuban”]EDIT : en fait, cela ne dérange pas la commande iptables, je me suis gourré.[/quote]Oui, je m’étais posé la question aussi, mais ça ne dérange pas iptables, il ne prend pas en compte la variable si elle est vide.

@PascalHambourg,
Je compte faire le même script pour ipv6.
J’ai lu ceci[quote]ip6tables works in exactly the same way as iptables does[/quote]ici: debian-administration.org/ar … IPv6_aware

Est-ce qu’il suffit de remplacer iptables par ip6tables ?
J’ai déjà un script en fonction qui ressemble à ce que nous avons fait ici.
Un ip6tables -S me donne ça:

-P INPUT DROP -P FORWARD DROP -P OUTPUT ACCEPT -A INPUT -i lo -j ACCEPT -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT -A INPUT -p ipv6-icmp -j ACCEPT -A INPUT -p tcp -m tcp --dport 80 -j ACCEPT -A INPUT -p tcp -m tcp --dport 443 -j ACCEPT -A INPUT -j LOG -A OUTPUT -p ipv6-icmp -j ACCEPT

Est-ce suffisant pour bloquer tout sauf les pings et le serveur Web ?

Re,
Alors, on en avait déjà parlé de l’IPv6…

Si je ne me plante pas, il suffirait de virer les règles NAT (plus de table NAT en IPv6)
IPv6 n’aime pas non plus cette ligne:

J’ai remplacé par ceci:

Edit: Oubliez, j’avais pas pensé qu’il y avait une commande particulière pour l’IPv6…

[quote=“lol”]J’ai galéré un peu plus que prévu, je me suis aperçu que le version des kernels pouvaient avoir jusqu’a 6 caractères
Mais je n’ai pas de machine avec un noyau en dessous de 2.6.36[/quote]
Tu peux tester en remplaçant le résultat de “uname -r” par ce que tu veux.
Mais je ne pense pas que supprimer les points et comparer les chiffres résultants soit une bonne approche. Par exemple, ton test est mis en défaut par la version 2.6.8.1. AMA, la seule méthode fiable consiste à comparer chaque nombre entre les points.

Non, cela ne pose pas de problème. Par contre si on veut éviter à monsieur pinpin d’oublier le -i, on peut l’ajouter si la variable n’est pas vide :

# Ajustez le nom de l'interface pour restreindre le trafic entrant à cette interface particulière. Par exemple : IFACE="eth0" #IFACE="eth0" if [ -n "${IFACE}" ] IFACE="-i ${IFACE}" fi

“iptables -L” n’affiche pas tout. Utilise plutôt iptables-save.

Non. ip6tables fonctionne de façon similaire à iptables, mais ça ne suffit pas : IPv6 fonctionne différemment d’IPv4. Notamment comme tu l’as vu, ICMP est remplacé par ICMPv6 ou IPv6-ICMP, et ARP est remplacé et étendu par NDP qui est un sous-ensemble d’ICMPv6 et plus un protocole à part, utilisation massive du multicast).
Aussi, le suivi de connexion de netfilter (conntrack) pour IPv6 fonctionne différemment de celui pour IPv4, la différence majeure étant qu’il ne réassemble pas les paquets fragmentés dès leur réception (en fait si, mais juste pour le suivi de connexion, ensuite il réinjecte les fragments originels dans ip6tables ; à noter que ça a changé depuis le noyau 3.7 en même temps que l’introduction du NAT IPv6 qui rendait ce changement de fonctionnement nécessaire).
Cela a un impact majeur : quand on active le suivi de connexion, iptables ne voit jamais de fragments (sauf la table “raw”) alors qu’ip6tables les voit. Il faut en tenir compte dans les règles de filtrage.
Comme je l’ai déjà écrit, j’ai encore des vérifications à faire avant de proposer quelque chose.

Le NAT IPv6 est supporté à partir du noyau 3.7. Ce n’est pas une raison pour s’en servir, il devrait être inutile dans la plupart des cas.

Salut,

[quote=“PascalHambourg”]Tu peux tester en remplaçant le résultat de “uname -r” par ce que tu veux.
Mais je ne pense pas que supprimer les points et comparer les chiffres résultants soit une bonne approche. Par exemple, ton test est mis en défaut par la version 2.6.8.1. AMA, la seule méthode fiable consiste à comparer chaque nombre entre les points.[/quote]Oui, c’est ce j’avais fini par faire plutôt que tester le script dans mes machines…

Je ne m’arrête pas aux trois premiers chiffres dans ma méthode je vais jusqu’à quatre (moins de 4 j’ajoute un zero, ) plus de 4 je coupe.

2.6.8.1 = 2681 (> 2636)
2.6.32.14 = 2632 (< 2636)
2.6.3 = 2630 (< 2636)
2.6.36.4 = 2636 (= 2636)
3.1.1 = 3110 (> 2636)

ça fonctionne donc aussi pour les 2.6.36.x car il faut que ce soit supérieur ou égal (le bol…), donc toute la série 2.6.36.xx passe.
Je crois donc que ça fonctionne quelque soit le noyau (de trois à 6 nombres). Maintenant, au lieu de couper à 4 je pourrais aller à 6.
Je vais quand même regarder comment tester chaque nombre, c’est plus “sérieux”! :wink:

Pour l’IPv6 je continue avec le script tel que je l’ai fait (tout interdire sauf 80/443) car je n’en ai pas besoin pour l’instant, mais ça va devenir problématique rapidement.
Je pense notamment à fail2ban qui n’est pas IPv6 “compliant” (enfin je n’ai pas vu d’annonce récente à ce sujet).

Merci pour tes conseils, donc (si mon test est valable) le script v4 peux être mis sur le Wiki.

D’après ton test, 2.6.8.1 >= 2.6.36, ce résultat ne te choque pas ?
Idem avec toutes les versions 2.6.x ou x est compris entre 4 et 9.
Le test se trompe aussi pour les versions 3.x avec x compris entre 0 et 9 car il faudrait ajouter deux zéros au lieu d’un.

Re,

D’après ton test, 2.6.8.1 >= 2.6.36, ce résultat ne te choque pas ?
Idem avec toutes les versions 2.6.x ou x est compris entre 4 et 9.[/quote]Maintenant que tu mets le doigt dessus… Bien sur, quelle buse! :075
Ok, je vais faire comme tu le préconises, c’est évidemment la solution.

Merci.

Salut,
C’est TRES moche, mais ça fonctionne (enfin).
Je ne garde que la version du noyau (majeur, mineur et la révision) et je vire tout le reste (du coup c’est compatible avec les noyaux “spéciaux” d’OVH (dans ce genre: 3.8.13-xxxx-grs-ipv6-64).

[code]#!/bin/sh
version=$(uname -r| cut -f1 -d"-")
major=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[1]}'
minor=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[2]}'
revis=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[3]}'

if [ $major -gt 2 ]
then
k2636=1
else
if [ $major -lt 2 ]
then
k2636=0
else
if [ $minor -gt 6 ]
then
k2636=1
else
if [ $minor -lt 6 ]
then
k2636=o
else
if [ $revis -ge 36 ]
then
k2636=1
else
k2636=0
fi
fi
fi
fi
fi

exit 0
[/code]

Je suis certain qu’il y a moyen de faire plus court et plus joli, mais je n’en suis pas capable…
Une bonne âme (qui sera chagrinée -au mieux - par mon code) voudra peut-être améliorer ça ?

Merci. :006

[quote=“lol”]
Je suis certain qu’il y a moyen de faire plus court et plus joli, mais je n’en suis pas capable…
Une bonne âme (qui sera chagrinée -au mieux - par mon code) voudra peut-être améliorer ça ?

Merci. :006[/quote]
Envoie ça à Michel, il va te le réduire à 2 ou 3 lignes … s’il est fatigué, sinon une seule suffira :laughing: :laughing: :laughing:

Salut,

[quote=“ricardo”]Envoie ça à Michel, il va te le réduire à 2 ou 3 lignes … s’il est fatigué, sinon une seule suffira [/quote]Je vais pas l’enquiquiner pour si peu!

Bref, j’ai fais un peu plus bref…

[code]#!/bin/sh
version=$(uname -r| cut -f1 -d"-")
major=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[1]}'
minor=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[2]}'
revis=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[3]}'
if [ $major -gt 2 ] ; then k2636=1
elif [ $major -lt 2 ] ; then k2636=0
elif [ $minor -gt 6 ] ; then k2636=1
elif [ $minor -lt 6 ] ; then k2636=0
elif [ $revis -ge 36 ] ; then k2636=1
else k2636=0
fi

exit 0
[/code]

Vous seriez sympa de tester chez vous…
Suffit d’ajouter echo $k2636 à la fin avant exit 0
Si ça sort 0 votre noyau doit être inférieur à 2.6.36 si ça sort 1 >=.

Salut,

Nickel lol !

  • Sur une Wheezy.

[13:40:08][root@USER] ~ # ./pare-feu_simplifié.sh 1 [13:40:13][root@USER] ~ #

[code]~ # cat pare-feu_simplifié.sh
#!/bin/sh
version=$(uname -r| cut -f1 -d"-")
major=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[1]}'
minor=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[2]}'
revis=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[3]}'
if [ $major -gt 2 ] ; then k2636=1
elif [ $major -lt 2 ] ; then k2636=0
elif [ $minor -gt 6 ] ; then k2636=1
elif [ $minor -lt 6 ] ; then k2636=O
elif [ $revis -ge 36 ] ; then k2636=1
else k2636=0
fi

echo $k2636

exit 0
~ # [/code]

[13:42:06][root@USER] ~ # uname -a && lsb_release -a Linux USER 3.2.0-4-686-pae #1 SMP Debian 3.2.46-1 i686 GNU/Linux No LSB modules are available. Distributor ID: Debian Description: Debian GNU/Linux 7.1 (wheezy) Release: 7.1 Codename: wheezy [13:42:11][root@USER] ~ #

  • Sur une Squeeze.

root@Fistons:~# ./pare-feu-simplifié.sh 0 root@Fistons:~# uname -a && lsb_release -a Linux Fistons 2.6.32-5-686 #1 SMP Fri May 10 08:33:48 UTC 2013 i686 GNU/Linux No LSB modules are available. Distributor ID: Debian Description: Debian GNU/Linux 6.0.7 (squeeze) Release: 6.0.7 Codename: squeeze root@Fistons:~#

Cela dit, bravo, quel taff ! :023

[quote=“BelZéButh”]Cela dit, bravo, quel taff ! [/quote]Tout le mérite en revient à Thuban et PascalHambourg, j’ai juste servi de catalyseur.

Voici donc ce qui pourrait être la version finale:

[code]#!/bin/sh

BEGIN INIT INFO

Provides: parefeu

Required-Start: $local_fs

Should-Start:

Required-Stop: $local_fs

Should-Stop:

X-Start-Before: $network

X-Stop-After: $network

Default-Start: S

Default-Stop: 0 6

Short-description: Configuration du pare-feu

Description: Met en place les règles iptables (IPv4 uniquement)

END INIT INFO

— Explications

Par défaut cette configuration s’applique à toutes les interfaces réseau.

Si vous souhaitez restreindre cela à une interface donnée, dé-commentez la ligne #IFACE=“eth0”

(dans la section variables)

Par défaut, le script autorise tout en sortie. Pour changer ce comportement veuillez indiquer quels sont les ports

autorisés en sortie dans les 2 variables suivantes (Tout sera bloqué sauf les ports inscrits)

$REMOTE_TCP_SERVICES

et/ou $REMOTE_UDP_SERVICES

- Pour configurer une machine qui fasse office de routeur, changez la valeur de la

variable ISROUTERNAT à true, ET configurez les interfaces ethx et ethy selon votre configuration.

=> ethx correspond à l’interface du LAN (reliée à votre Intranet)

=> ethy correspond à l’interface WAN (reliée à Internet ou à la truc-box)

— VARIABLES

. /lib/lsb/init-functions
readonly IPTABLES=/sbin/iptables

Services que le système offrira au réseau, à séparer avec des espaces

Par défaut RIEN n’est autorisé à part le Ping.

TCP_SERVICES="“
UDP_SERVICES=”"

Services que le système utilisera du réseau

(défaut : autorise TOUT en sortie si aucun port n’est précisé)

REMOTE_TCP_SERVICES="“
REMOTE_UDP_SERVICES=”"

Pour une machine faisant office de routeur avec NAT, changez la valeur de la variable ISROUTERNAT à “true”.

ISROUTERNAT=false

ethx correspond à l’interface du LAN

ethy correspond à l’interface reliée à la truc-box (à compléter seulement si vous activez la fonction routeur)

ethx="eth1"
ethy=“eth0”

Ajustez le nom de l’interface pour restreindre le trafic entrant à cette interface particulière.

Par exemple : IFACE=“eth0”

#IFACE=“eth0”

Activation des logs (mettre à “true” pour activer)

LOGGING=false

NE RIEN MODIFIER APRES CETTE LIGNE (à moins de savoir ce que vous faite)

if [ -n “${IFACE}” ] ; then
IFACE="-i ${IFACE}"
fi

Récupération de la version du noyau et test si >= à 2.6.36

version=$(uname -r| cut -f1 -d"-")
major=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[1]}'
minor=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[2]}'
revis=awk -v str=$version 'BEGIN {split(str, tk, "."); print tk[3]}'

if [ $major -gt 2 ] ; then k2636=1
elif [ $major -lt 2 ] ; then k2636=0
elif [ $minor -gt 6 ] ; then k2636=1
elif [ $minor -lt 6 ] ; then k2636=0
elif [ $revis -ge 36 ] ; then k2636=1
else k2636=0
fi

— FONCTIONS

fw_start () {

Vidage

fw_clear

Parefeu - Suppression des règles

Interdictions

$IPTABLES -t filter -P INPUT DROP
$IPTABLES -t filter -P FORWARD DROP
$IPTABLES -t filter -P OUTPUT DROP

Parefeu - interdictions générales établies

Loopback

$IPTABLES -t filter -A INPUT -i lo -j ACCEPT

Trafic d’entrée :

$IPTABLES -t filter -A INPUT ${IFACE} -m state --state ESTABLISHED,RELATED -j ACCEPT

Limitation de la taille et de la fréquence des pings acceptés

$IPTABLES -A INPUT ${IFACE} -p icmp --icmp-type echo-request -m limit --limit 10/second -m length --length 8:2000 -j ACCEPT

Sortie autorisée, si aucun port autorisé en sortie n’est défini

if [ -z “$REMOTE_TCP_SERVICES”] && [ -z “$REMOTE_UDP_SERVICES” ]; then
$IPTABLES -t filter -A OUTPUT -j ACCEPT
else
$IPTABLES -t filter -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
# Services à autoriser en sortie
for PORT in $REMOTE_TCP_SERVICES; do
$IPTABLES -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT
done
for PORT in $REMOTE_UDP_SERVICES; do
$IPTABLES -A OUTPUT -p udp --dport ${PORT} -j ACCEPT
done
fi

Services à autoriser en entrée

for PORT in $TCP_SERVICES; do
$IPTABLES -A INPUT ${IFACE} -p tcp --dport ${PORT} -j ACCEPT
done
for PORT in $UDP_SERVICES; do
$IPTABLES -A INPUT ${IFACE} -p udp --dport ${PORT} -j ACCEPT
done

Parefeu - Mise en place des règles

NAT

if $ISROUTERNAT ; then
$IPTABLES -A INPUT -i $ethx -j ACCEPT
$IPTABLES -A FORWARD -i $ethy -o $ethx -m state --state RELATED,ESTABLISHED -j ACCEPT
$IPTABLES -A FORWARD -i $ethx -o $ethy -j ACCEPT
$IPTABLES -t nat -A POSTROUTING -o $ethy -j MASQUERADE
# Parefeu - Routeur avec NAT
fi

Toutes les autres connexions sont enregistrées dans syslog (si activé)

if $LOGGING ; then
$IPTABLES -t filter -A INPUT -j LOG --log-level=4

Parefeu - Logging

fi

}

fw_save () {
iptables-save > /etc/firewall
}

fw_clear () {
$IPTABLES -t filter -F
$IPTABLES -t nat -F
$IPTABLES -t mangle -F
$IPTABLES -t raw -F
$IPTABLES -t filter -P INPUT ACCEPT
$IPTABLES -t filter -P OUTPUT ACCEPT
$IPTABLES -t filter -P FORWARD ACCEPT
$IPTABLES -t nat -P PREROUTING ACCEPT
$IPTABLES -t nat -P POSTROUTING ACCEPT
$IPTABLES -t nat -P OUTPUT ACCEPT
if [ $k2636 -eq 1 ] ; then
$IPTABLES -t nat -P INPUT ACCEPT
fi
$IPTABLES -t mangle -P PREROUTING ACCEPT
$IPTABLES -t mangle -P OUTPUT ACCEPT
$IPTABLES -t mangle -P POSTROUTING ACCEPT
$IPTABLES -t mangle -P FORWARD ACCEPT
$IPTABLES -t mangle -P INPUT ACCEPT
$IPTABLES -t raw -P OUTPUT ACCEPT
$IPTABLES -t raw -P PREROUTING ACCEPT
$IPTABLES -F
}

fw_status () {
$IPTABLES -L --line-numbers
}

-----------------------------------------------------------------------------

case “$1” in
start|restart)
log_daemon_msg "Starting firewall…"
fw_start
log_end_msg $?
;;
save)
log_daemon_msg "Saving firewall…"
fw_save
log_end_msg $?
;;
clean)
log_daemon_msg "Clearing firewall rules…"
fw_clear
log_end_msg $?
;;
status)
log_daemon_msg "Firewall status"
fw_status
;;
*)
log_action_msg "Usage $0 {start|save|restart|clean|status}"
exit 1
;;
esac
exit 0
[/code]

[quote=“lol”][quote=“BelZéButh”]Cela dit, bravo, quel taff ! [/quote]Tout le mérite en revient à Thuban et PascalHambourg, j’ai juste servi de catalyseur.
[/quote]
Dans mes pensées, ils y étaient inclus, également.

Ce n’est pas donné un catalyseur de nos jours. :slightly_smiling: