Préparer des règles Netfilter dans un espace de noms réseau

Vincent Bernat

Sou­vent, les règles d’un pare-feu sont mises en place à l’aide d’un script fai­sant ap­pel aux com­mandes iptables et ip6tables. Cela per­met no­tam­ment d’uti­li­ser des va­riables et des boucles. Il y a ce­pen­dant trois in­con­vé­nients ma­jeurs à cette méthode :

  1. Pen­dant toute la du­rée du script, le pare-feu est tem­po­rai­re­ment in­com­plet : les nou­velles connexions peuvent ne pas être au­to­ri­sées à s’éta­blir ou, in­ver­se­ment, le pare-feu peut au­to­ri­ser des flux qui ne de­vraient pas l’être. Les règles de NAT né­ces­saires au bon fonc­tion­ne­ment du rou­teur peuvent éga­le­ment être absentes.

  2. Si une er­reur sur­vient, le pare-feu reste dans un état in­ter­mé­diaire. Il est alors né­ces­saire de s’as­su­rer que les règles au­to­ri­sant l’ac­cès à dis­tance soient pla­cées très tôt pour gar­der la main. Un sys­tème de re­tour au­to­ma­tique à la pré­cé­dente ver­sion est éga­le­ment né­ces­saire pour cor­ri­ger la si­tua­tion ra­pidement.

  3. Construire de nom­breuses règles peut être très lent. Chaque ap­pel à ip{,6}tables va ra­pa­trier l’en­semble des règles du noyau, ajou­ter la règle vou­lue et ren­voyer le tout au noyau.

Mise à jour (08.2021)

Bien que la so­lu­tion ex­po­sée dans cet ar­ticle soit tou­jours cor­recte, une meilleure al­ter­na­tive est de mi­grer vers nf­tables. Il cor­rige ces écueils.

Avec iptables-restore#

Une fa­çon clas­sique de ré­soudre ces trois as­pects et de construire un fi­chier de règles qui sera lu par iptables-restore et ip6tables-restore1. Ces ou­tils en­voient en une seule passe les règles au noyau qui les ap­plique de ma­nière ato­mique. Ha­bi­tuel­le­ment, un tel fi­chier est construit par ip{,6}tables-save mais un script peut éga­le­ment faire l’affaire.

Mise à jour (04.2016)

ferm, un ou­til pour main­te­nir un pare-feu, consti­tue une so­lu­tion al­ter­na­tive à cette approche.

La syn­taxe com­prise par ip{,6}tables-restore est si­mi­laire à celle de ip{,6}tables. Ce­pen­dant, chaque table dis­pose de son propre bloc et les chaînes doivent être dé­cla­rées dif­fé­rem­ment. Voyons un exemple :

$ iptables -P FORWARD DROP
$ iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -j MASQUERADE
$ iptables -N SSH
$ iptables -A SSH -p tcp --dport ssh -j ACCEPT
$ iptables -A INPUT -i lo -j ACCEPT
$ iptables -A OUTPUT -o lo -j ACCEPT
$ iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
$ iptables -A FORWARD -j SSH
$ iptables-save
*nat
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -s 192.168.0.0/24 -j MASQUERADE
COMMIT

*filter
:INPUT ACCEPT [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]
:SSH - [0:0]
-A INPUT -i lo -j ACCEPT
-A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -j SSH
-A OUTPUT -o lo -j ACCEPT
-A SSH -p tcp -m tcp --dport 22 -j ACCEPT
COMMIT

La table nat et la table filter dis­posent cha­cune de leur bloc. La chaîne SSH est dé­cla­rée en haut du bloc de la table filter avec les autres chaînes par défaut.

Voici un script qui dé­tourne les com­mandes ip{,6}tables afin de construire un tel fi­chier en s’ap­puyant mas­si­ve­ment sur Zsh2 :

#!/bin/zsh
set -e

work=$(mktemp -d)
trap "rm -rf $work" EXIT

# ❶ Redefine ip{,6}tables
iptables() {
    # Intercept -t
    local table="filter"
    [[ -n ${@[(r)-t]} ]] && {
        # Which table?
        local index=${(k)@[(r)-t]}
        table=${@[(( index + 1 ))]}
        argv=( $argv[1,(( $index - 1 ))] $argv[(( $index + 2 )),$#] )
    }
    [[ -n ${@[(r)-N]} ]] && {
        # New user chain
        local index=${(k)@[(r)-N]}
        local chain=${@[(( index + 1 ))]}
        print ":${chain} -" >> ${work}/${0}-${table}-userchains
        return
    }
    [[ -n ${@[(r)-P]} ]] && {
        # Policy for a builtin chain
        local index=${(k)@[(r)-P]}
        local chain=${@[(( index + 1 ))]}
        local policy=${@[(( index + 2 ))]}
        print ":${chain} ${policy}" >> ${work}/${0}-${table}-policy
        return
    }
    # iptables-restore only handle double quotes
    echo ${${(q-)@}//\'/\"} >> ${work}/${0}-${table}-rules #'
}
functions[ip6tables]=${functions[iptables]}

# ❷ Build the final ruleset that can be parsed by ip{,6}tables-restore
save() {
    for table (${work}/${1}-*-rules(:t:s/-rules//)) {
        print "*${${table}#${1}-}"
        [ ! -f ${work}/${table}-policy ] || cat ${work}/${table}-policy
        [ ! -f ${work}/${table}-userchains || cat ${work}/${table}-userchains
        cat ${work}/${table}-rules
        print "COMMIT"
    }
}

# ❸ Execute rule files
for rule in $(run-parts --list --regex '^[.a-zA-Z0-9_-]+$' ${0%/*}/rules); do
    . $rule
done

# ❹ Execute rule files
ret=0
save iptables  | iptables-restore  || ret=$?
save ip6tables | ip6tables-restore || ret=$?
exit $ret

En ❶, une nou­velle fonc­tion iptables() est dé­fi­nie et masque la com­mande du même nom. Elle tente de lo­ca­li­ser le pa­ra­mètre -t pour sa­voir quelle table est concer­née par la règle. Si le pa­ra­mètre est pré­sent, la table est mé­mo­ri­sée dans la va­riable $iptables et le pa­ra­mètre est re­tiré de la liste des ar­gu­ments. La dé­fi­ni­tion d’une nou­velle chaîne avec -N ou la mise en place d’une po­li­tique par dé­faut avec -P sont éga­le­ment gérés.

En ❷, la fonc­tion save() va émettre les règles qui se­ront lues par ip{,6}tables-restore. En ❸, les règles de l’uti­li­sa­teur sont exé­cu­tées. Chaque com­mande ip{,6}tables ap­pelle en réa­lité la fonc­tion pré­cé­dem­ment dé­fi­nie. Si au­cune er­reur n’est sur­ve­nue, en ❹, les com­mandes ip{,6}tables-restore sont in­voquées.

Cette mé­thode est par­fai­te­ment fonc­tion­nelle3. Tou­te­fois, la mé­thode sui­vante est bien plus élégante.

Avec un espace de noms#

Une ap­proche hy­bride est de construire les règles avec ip{,6}tables dans un es­pace de noms ré­seau (net­work na­mes­pace) puis de les sau­ver avec ip{,6}tables-save et en­fin de les ap­pli­quer dans l’es­pace de noms prin­ci­pal avec ip{,6}tables-restore.

#!/bin/zsh
set -e

alias main='/bin/true ||'
[ -n $iptables ] || {
    # ❶ Execute ourself in a dedicated network namespace
    iptables=1 unshare --net -- \
        $0 4> >(iptables-restore) 6> >(ip6tables-restore)
    # ❷ In main namespace, disable iptables/ip6tables commands
    alias iptables=/bin/true
    alias ip6tables=/bin/true
    alias main='/bin/false ||'
}

# ❸ In both namespaces, execute rule files
for rule in $(run-parts --list --regex '^[.a-zA-Z0-9_-]+$' ${0%/*}/rules); do
    . $rule
done

# ❹ In test namespace, save the rules
[ -z $iptables ] || {
    iptables-save >&4
    ip6tables-save >&6
}

En ❶, le script est ré­exé­cuté dans un nou­vel es­pace de noms ré­seau. Ce­lui-ci dis­pose de ces propres règles de pare-feu qui peuvent être mo­di­fiées sans al­té­rer celles de l’es­pace de noms prin­ci­pal. La va­riable $iptables est uti­li­sée pour dé­ter­mi­ner quel est l’es­pace de noms cou­rant. Dans le nou­vel es­pace de noms, les fi­chiers de règles sont exé­cu­tés (❸). Ceux-ci contiennent l’ap­pel aux com­mandes ip{,6}tables. Si une er­reur sur­vient, nous n’al­lons pas plus loin grâce à l’uti­li­sa­tion de set -e. Si­non, en ❹, les règles sont sau­ve­gar­dées avec ip{,6}tables-save et en­voyées dans l’es­pace de noms prin­ci­pal en uti­li­sant les des­crip­teurs de fi­chier dé­diés à cet effet.

L’exé­cu­tion dans l’es­pace de noms prin­ci­pal conti­nue en ❶. Les ré­sul­tats de ip{,6}tables-save sont en­voyées à ip{,6}tables-restore. À ce point, le pare-feu est presque fonc­tion­nel. Les fi­chiers de règles sont tou­te­fois re­joués (❸) mais les com­mandes ip{,6}tables sont neu­tra­li­sées (❷) de fa­çon à ce que les éven­tuelles autres com­mandes, comme par exemple l’ac­ti­va­tion du rou­tage IP, soient exécutées.

Le nou­vel es­pace de noms ne dis­pose pas du même en­vi­ron­ne­ment que l’es­pace de noms prin­ci­pal. No­tam­ment, il ne contient pas d’in­ter­faces ré­seau. Il n’est donc pas pos­sible de consul­ter ou de confi­gu­rer des adresses IP. Lorsque des com­mandes ne peuvent être exé­cu­tées que dans l’es­pace de noms prin­ci­pal, il est né­ces­saire de les pré­fixer par main :

main ip addr add 192.168.15.1/24 dev lan-guest

Je­tez un coup d’œil sur un exemple com­plet sur GitHub.