« Parefeu Simplifié » : différence entre les versions

Aller à la navigation Aller à la recherche

Parefeu Simplifié (voir la source)

Version du 29 avril 2017 à 21:59

10 387 octets ajoutés ,  il y a 8 ans
m
aucun résumé des modifications
Aucun résumé des modifications
mAucun résumé des modifications
 
(26 versions intermédiaires par 6 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
== Introduction ==
== Introduction ==


La méthode proposée [[Netfilter/Iptables_introduction | ici]] pose parfois souci lors d'un changement de version du noyau, qui ne comprends pas les règles enregistrées avec iptables-save comme il faut.
La méthode proposée [[Netfilter/Iptables_introduction | ici]] pose parfois souci lors d'un changement de version du noyau, qui ne comprend pas les règles enregistrées avec iptables-save comme il faut.


Dans la suite, vous trouverez un script permettant d'établir les règles à chaque démarrage. De plus, ce script ajoute par défaut un enregistrement des erreurs dans les logs, ce qui facilite la surveillance avec [[ Logwatch | logwatch ]] par exemple.
Dans la suite, vous trouverez un script permettant d'établir les règles à chaque démarrage. De plus, ce script ajoute par défaut un enregistrement des erreurs dans les logs, ce qui facilite la surveillance avec [[ Logwatch | logwatch ]] par exemple.
Si à l'avenir vous souhaitez ajoutez ou supprimer certaines règles, vous verrez que le script est construit de façon à faciliter ce genre d'opération.
Si à l'avenir vous souhaitez ajoutez ou supprimer certaines règles, vous verrez que le script est construit de façon à faciliter ce genre d'opération.


== Installation du Pare-feu ==
== Installation du Pare-feu ==
''' Attention, les commandes suivantes sont à éxécuter avec les droits superutilisateur'''
''' Attention, les commandes suivantes sont à exécuter avec les droits superutilisateur'''
Copiez-collez le script suivant dans /etc/init.d/mon_parefeu.
Copiez-collez le script suivant dans /etc/init.d/mon_parefeu.
Ensuite, rendez ce script éxécutable :  
Ensuite, rendez ce script exécutable :  
  chmod +x /etc/init.d/mon_parefeu
  chmod +x /etc/init.d/mon_parefeu
Puis activer le chargement du script au démarrage :  
Puis activer le chargement du script au démarrage :  
  insserv mon_parefeu
  insserv mon_parefeu
== Le script ==
== Le script ==


<code>#!/bin/sh
<syntaxhighlight lang="bash">#!/bin/sh
 
### BEGIN INIT INFO
### BEGIN INIT INFO
# Provides:          mon_parefeu
# Provides:          mon_parefeu
Ligne 26 : Ligne 26 :
# X-Start-Before:    $network
# X-Start-Before:    $network
# X-Stop-After:      $network
# X-Stop-After:      $network
# Default-Start:      2 3 4 5
# Default-Start:      S
# Default-Stop:      0 1 6
# Default-Stop:      0 6
# Short-description:  Configure le parefeu
# Short-description:  Configure le parefeu
# Description:        Met en place les règles iptables.
# Description:        Met en place les règles iptables.
### END INIT INFO
### END INIT INFO
 
# Exemple de configuration de pare-feu
#------------------------Explications----------------------------------#
#
#
# Défauts :
# Défauts :
# - Cette configuration s'applique à toutes les interfaces réseau.
# - Cette configuration s'applique à toutes les interfaces réseau.
#  Si vous voulez ne restreindre cela qu'à une interface donnée,
#  Si vous voulez restreindre cela à une interface donnée,
#  utilisez '-i INTERFACE' dans les appels iptables.
#  utilisez '-i INTERFACE' dans la variables $IPTABLES.
#
# - 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
#
#
# - Par défaut, le script autorise tout en sortie. Pour changer ce comportement
# - Pour configurer une machine routeur,  
#  veuillez commenter la ligne /sbin/iptables -t filter -P OUTPUT ACCEPT
#  changez la valeur de la variable
#  et décommenter les lignes #REMOTE_TCP_SERVICES=""
#  ISROUTERNAT à true, ainsi que
#                            #REMOTE_UDP_SERVICES=""
#  les interfaces ethx et ethy selon votre configuration
#  ainsi que les blocs suivant : #if [ -n "$REMOTE_TCP_SERVICES" ] ; then
#         ethx correspond à l'interface du LAN
#   et                                  #if [ -n "$REMOTE_UDP_SERVICES" ] ; then
#         ethy correspond à l'interface reliée à la truc-box
#
#
# description: Active/Désactive le pare-feu au démarrage
# description: Active/Désactive le pare-feu au démarrage
#
#
#---------------------------------------------------------------
#----------------------------------------------------------------------#
 
#------------------------VARIABLES-------------------------------------#
readonly IPTABLES=/sbin/iptables


PATH=/bin:/sbin:/usr/bin:/usr/sbin
. /lib/lsb/init-functions


# Services que le systèmes offrira au réseau, à séparer avec des espaces
# Services que le système offrira au réseau, à séparer avec des espaces
# ftp : 21, ssh : 22, serveur web : 80, cups : 632, jabber : 5222
# ftp : 21, ssh : 22, serveur web : 80, cups : 631, jabber : 5222
TCP_SERVICES=""  
TCP_SERVICES=""  
UDP_SERVICES=""
UDP_SERVICES=""
# Services que le système utilisera du réseau
# Services que le système utilisera du réseau
# Décommenter ces lignes pour limiter les services en sortie (défaut : autorise tout en sortie)
# (défaut : autorise tout en sortie)
#REMOTE_TCP_SERVICES=""  
REMOTE_TCP_SERVICES=""  
#REMOTE_UDP_SERVICES=""  
REMOTE_UDP_SERVICES=""  


if ! [ -x /sbin/iptables ]; then   
# 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"
#----------------------------------------------------------------------#
 
if ! [ -x $IPTABLES ]; then   
exit 0
exit 0
fi
fi
 
#----------------------------FONCTIONS---------------------------------#
fw_start () {
fw_start () {
 
# Vidage
# Vidage
/sbin/iptables -t filter -F
fw_clear
/sbin/iptables -t filter -X
# Parefeu - Suppression des règles
/sbin/iptables -t nat -F
/sbin/iptables -t nat -X
/sbin/iptables -t mangle -F
/sbin/iptables -t mangle -X
 
echo "Parefeu - Suppression des règles : [OK]"
 
# Interdictions
# Interdictions
/sbin/iptables -t filter -P INPUT DROP
$IPTABLES -t filter -P INPUT DROP
/sbin/iptables -t filter -P FORWARD DROP
$IPTABLES -t filter -P FORWARD DROP
/sbin/iptables -t filter -P OUTPUT DROP
$IPTABLES -t filter -P OUTPUT DROP
 
echo "Parefeu - interdictions générales établies : [OK]"
# Parefeu - interdictions générales établies
 
# Loopback
# Loopback
/sbin/iptables -t filter -A INPUT -i lo -j ACCEPT
$IPTABLES -t filter -A INPUT -i lo -j ACCEPT
/sbin/iptables -t filter -A INPUT -i lo -j ACCEPT
 
# Trafic d'entrée :
# Trafic d'entrée :
/sbin/iptables -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPTABLES -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
 
# Refus du ping
# Refus du ping pour éviter de répondre aux scans des éventuels vilains
/sbin/iptables -t filter -A INPUT -p icmp -j LOG
$IPTABLES -t filter -A INPUT -p icmp -j LOG
/sbin/iptables -t filter -A INPUT -p icmp -j DROP
$IPTABLES -t filter -A INPUT -p icmp -j DROP
 
# Sortie autorisée,  
# Sortie autorisée, si aucun port autorisé en sortie n'est défini
# à commenter si seuls certains services doivent être autorisés en sortie.
# Sinon, on autorise le loopback et les connexions déjà établies
/sbin/iptables -t filter -P OUTPUT ACCEPT
        if [ -z "$REMOTE_TCP_SERVICES"] && [ -z "$REMOTE_UDP_SERVICES" ]; then
 
            $IPTABLES -t filter -P OUTPUT ACCEPT
        else
            $IPTABLES -t filter -A OUTPUT -o lo -j ACCEPT
            $IPTABLES -t filter -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
        fi
# Services à autoriser en entrée
# Services à autoriser en entrée
if [ -n "$TCP_SERVICES" ] ; then
for PORT in $TCP_SERVICES; do
for PORT in $TCP_SERVICES; do
$IPTABLES -A INPUT -p tcp --dport ${PORT} -j ACCEPT
/sbin/iptables -A INPUT -p tcp --dport ${PORT} -j ACCEPT
done
done
fi
for PORT in $UDP_SERVICES; do
if [ -n "$UDP_SERVICES" ] ; then
$IPTABLES -A INPUT -p udp --dport ${PORT} -j ACCEPT
for PORT in $UDP_SERVICES; do
done
/sbin/iptables -A INPUT -p udp --dport ${PORT} -j ACCEPT
done
# 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
# Parefeu - Mise en place des règles
if $ISROUTERNAT ; then
$IPTABLES -A INPUT -i $ethx -j ACCEPT
$IPTABLES -A INPUT -p icmp -j ACCEPT
$IPTABLES -A FORWARD -i $ethy -o $ethx -m state --state RELATED,ESTABLISHED -j ACCEPT
$IPTABLES -A FORWARD -o $ethy -j ACCEPT
$IPTABLES -t nat -A POSTROUTING -o $ethy -j MASQUERADE
# Parefeu - Routeur avec NAT
fi
fi
 
# Décommenter les lignes suivantes pour n'autoriser que certains
# services en sortie
 
#if [ -n "$REMOTE_TCP_SERVICES" ] ; then
# for PORT in $REMOTE_TCP_SERVICES; do
# /sbin/iptables -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT
# done
#fi
#if [ -n "$REMOTE_UDP_SERVICES" ] ; then
# for PORT in $REMOTE_UDP_SERVICES; do
# /sbin/iptables -A OUTPUT -p udp --dport ${PORT} -j ACCEPT
# done
#fi
 
echo "Parefeu - Mise en place des règles : [OK]"
 
# Décommenter les lignes après les traits
# pour une machine faisant office de routeur avec NAT
#
# ethx correspond à l'interface du LAN
# ethy correspond à l'interface reliée à la truc-box
# -------------------------------------------
 
#/sbin/iptables -A INPUT -i ethx -j ACCEPT
#/sbin/iptables -A INPUT -p icmp -j ACCEPT
#/sbin/iptables -A FORWARD -i ethy -o ethx -m state --state RELATED,ESTABLISHED -j ACCEPT
#/sbin/iptables -A FORWARD -o ethy -j ACCEPT
#/sbin/iptables -t nat -A POSTROUTING -o ethy -j MASQUERADE
 
#echo "Parefeu - Routeur avec NAT : [OK]"
 
# Toutes les autres connexions sont enregistrées dans syslog
# Toutes les autres connexions sont enregistrées dans syslog
#/sbin/iptables -t filter -A OUTPUT -j LOG
#$IPTABLES -t filter -A OUTPUT -j LOG
/sbin/iptables -t filter -A INPUT -j LOG --log-level=4
$IPTABLES -t filter -A INPUT -j LOG --log-level=4
 
echo "Parefeu - Logging : [OK]"
# Parefeu - Logging
}
}
 
fw_stop () {
fw_stop () {
/sbin/iptables -F
#$IPTABLES -F
/sbin/iptables -t nat -F
#$IPTABLES -t nat -F
/sbin/iptables -t mangle -F
#$IPTABLES -t mangle -F
/sbin/iptables -P INPUT DROP
#$IPTABLES -P INPUT DROP
/sbin/iptables -P FORWARD DROP
#$IPTABLES -P FORWARD DROP
/sbin/iptables -P OUTPUT ACCEPT
#$IPTABLES -P OUTPUT ACCEPT
iptables-save > /etc/firewall
}
}
 
fw_clear () {
fw_clear () {
/sbin/iptables -t filter -F
$IPTABLES -t filter -F
/sbin/iptables -t nat -F
$IPTABLES -t nat -F
/sbin/iptables -t mangle -F
$IPTABLES -t mangle -F
/sbin/iptables -t raw -F
$IPTABLES -t raw -F
/sbin/iptables -t filter -P INPUT ACCEPT
$IPTABLES -t filter -P INPUT ACCEPT
/sbin/iptables -t filter -P OUTPUT ACCEPT
$IPTABLES -t filter -P OUTPUT ACCEPT
/sbin/iptables -t filter -P FORWARD ACCEPT
$IPTABLES -t filter -P FORWARD ACCEPT
/sbin/iptables -t nat -P PREROUTING ACCEPT
$IPTABLES -t nat -P PREROUTING ACCEPT
/sbin/iptables -t nat -P POSTROUTING ACCEPT
$IPTABLES -t nat -P POSTROUTING ACCEPT
/sbin/iptables -t nat -P OUTPUT ACCEPT
$IPTABLES -t nat -P OUTPUT ACCEPT
/sbin/iptables -t mangle -P PREROUTING ACCEPT
$IPTABLES -t mangle -P PREROUTING ACCEPT
/sbin/iptables -t mangle -P OUTPUT ACCEPT
$IPTABLES -t mangle -P OUTPUT ACCEPT
/sbin/iptables -t mangle -P POSTROUTING ACCEPT
$IPTABLES -t mangle -P POSTROUTING ACCEPT
/sbin/iptables -t mangle -P FORWARD ACCEPT
$IPTABLES -t mangle -P FORWARD ACCEPT
/sbin/iptables -t mangle -P INPUT ACCEPT
$IPTABLES -t mangle -P INPUT ACCEPT
/sbin/iptables -t raw -P OUTPUT ACCEPT
$IPTABLES -t raw -P OUTPUT ACCEPT
/sbin/iptables -t raw -P PREROUTING ACCEPT
$IPTABLES -t raw -P PREROUTING ACCEPT
/sbin/iptables -F
$IPTABLES -F
}
}
 
fw_status () {
fw_status () {
/sbin/iptables -L --line-numbers
$IPTABLES -L --line-numbers
}
}


#----------------------------------------------------------------------#
case "$1" in
case "$1" in
start|restart)
start|restart)
echo "Starting firewall.."
log_daemon_msg "Starting firewall.."
fw_stop
  fw_start
  fw_start
echo "done."
log_end_msg $?
  ;;
  ;;
stop)
stop)
echo "Stopping firewall.."
log_daemon_msg "Stopping firewall.."
  fw_stop
  fw_stop
echo "done."
log_end_msg $?
  ;;
  ;;
clean)
clean)
  echo "Clearing firewall rules.."
  log_daemon_msg "Clearing firewall rules.."
  fw_clear
  fw_clear
echo "done."
log_end_msg $?
  ;;
  ;;
status)
status)
echo "Firewall status"
log_daemon_msg "Firewall status"
fw_status
fw_status
;;
;;
*)
*)
  echo "Usage: $0 {start|stop|restart|clean|status}"
  log_action_msg "Usage $0 {start|stop|restart|clean|status}"
  exit 1
  exit 1
  ;;
  ;;
esac
esac
exit 0
exit 0
</code>
 
</syntaxhighlight>


== Ouvrir des ports ==
== Ouvrir des ports ==
Ligne 222 : Ligne 227 :


== Autoriser au cas par cas en sortie ==
== Autoriser au cas par cas en sortie ==
Il faut commenter la ligne :
Complétez entre les guillemets les ports à ouvrir en sortie :
/sbin/iptables -t filter -P OUTPUT ACCEPT
  REMOTE_TCP_SERVICES=""  
et décommenter ces lignes :
  REMOTE_UDP_SERVICES=""
#REMOTE_TCP_SERVICES=""
#REMOTE_UDP_SERVICES=""
Complétez entre les guillements les ports à ouvrir en sortie.
Enfin, décommentez ces blocs :  
  #if [ -n "$REMOTE_TCP_SERVICES" ] ; then
  # for PORT in $REMOTE_TCP_SERVICES; do
# /sbin/iptables -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT
# done
#fi
#if [ -n "$REMOTE_UDP_SERVICES" ] ; then
# for PORT in $REMOTE_UDP_SERVICES; do
# /sbin/iptables -A OUTPUT -p udp --dport ${PORT} -j ACCEPT
# done
#fi


== Cas d'une machine routeur avec NAT ==
== Cas d'une machine routeur avec NAT ==
Il va falloir décommenter ces lignes :  
Il va falloir décommenter ces lignes : (OBSOLETE voir ISROUTERNAT)
  #/sbin/iptables -A INPUT -i ethx -j ACCEPT
  #/sbin/iptables -A INPUT -i ethx -j ACCEPT
  #/sbin/iptables -A INPUT -p icmp -j ACCEPT
  #/sbin/iptables -A INPUT -p icmp -j ACCEPT
Ligne 247 : Ligne 238 :
  #/sbin/iptables -A FORWARD -o ethy -j ACCEPT
  #/sbin/iptables -A FORWARD -o ethy -j ACCEPT
  #/sbin/iptables -t nat -A POSTROUTING -o ethy -j MASQUERADE
  #/sbin/iptables -t nat -A POSTROUTING -o ethy -j MASQUERADE
#echo "Parefeu - Routeur avec NAT : [OK]"


#echo "Parefeu - Routeur avec NAT : [OK]"
En remplaçant ethx qui correspond à l'interface du LAN et ethy qui correspond à l'interface reliée à la truc-box
En remplaçant ethx qui correspond à l'interface du LAN et ethy qui correspond à l'interface reliée à la truc-box
== Le script (avec support ipv6)==
{{Warning|Text='''La version de ce script est encore en travaux, tant qu'elle n'est pas validée par personne compétente.'''}}
    #!/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,
    #  utilisez '-i INTERFACE' dans la variables $IPTABLES.
    #
    # - 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
    #
    #----------------------------------------------------------------------#
   
    . /lib/lsb/init-functions
   
    #------------------------VARIABLES-------------------------------------#
    # Mettre à 1 si vous utilisez IPV6 :
    IPV6=0
    # 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"
   
    # Chemins vers iptables
    readonly IPTABLES=/sbin/iptables
    readonly IP6TABLES=/sbin/ip6tables
    #----------------------------------------------------------------------#
   
    if ! [ -x $IPTABLES ]; then
        exit 0
    fi
   
    if [ $IPV6 -eq 1 ]; then
        if ! [ -x $IP6TABLES ]; then
            exit 0
        fi
    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 -m state --state ESTABLISHED,RELATED -j ACCEPT
         
    # Refus du ping pour éviter de répondre aux scans des éventuels vilains
        $IPTABLES -t filter -A INPUT -p icmp -j LOG
        $IPTABLES -t filter -A INPUT -p icmp -j DROP
         
    # 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 -P OUTPUT ACCEPT
            fi
         
    # Services à autoriser en entrée
        for PORT in $TCP_SERVICES; do
            $IPTABLES -A INPUT -p tcp --dport ${PORT} -j ACCEPT
        done
         
        for PORT in $UDP_SERVICES; do
            $IPTABLES -A INPUT -p udp --dport ${PORT} -j ACCEPT
        done
         
    # 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
        # Parefeu - Mise en place des règles
         
        if $ISROUTERNAT ; then
            $IPTABLES -A INPUT -i $ethx -j ACCEPT
            $IPTABLES -A INPUT -p icmp -j ACCEPT
            $IPTABLES -A FORWARD -i $ethy -o $ethx -m state --state RELATED,ESTABLISHED -j ACCEPT
            $IPTABLES -A FORWARD -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 INPUT -j LOG --log-level=4
   
    # Configuration IPV6 
        if [ $IPV6 -eq 1 ]; then
        # Interdictions
            $IP6TABLES -t filter -P INPUT DROP
            $IP6TABLES -t filter -P FORWARD DROP
            $IP6TABLES -t filter -P OUTPUT DROP
             
        # Loopback
            $IP6TABLES -t filter -A INPUT -i lo -j ACCEPT
             
        # Trafic d'entrée :
            $IP6TABLES -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
             
        # Refus du ping pour éviter de répondre aux scans des éventuels vilains
            $IP6TABLES -t filter -A INPUT -p icmp -j LOG
            $IP6TABLES -t filter -A INPUT -p icmp -j DROP
             
        # Sortie autorisée, si aucun port autorisé en sortie n'est défini
                if [ -z "$REMOTE_TCP_SERVICES"] && [ -z "$REMOTE_UDP_SERVICES" ]; then
                    $IP6TABLES -t filter -P OUTPUT ACCEPT
                fi
             
        # Services à autoriser en entrée
            for PORT in $TCP_SERVICES; do
                $IP6TABLES -A INPUT -p tcp --dport ${PORT} -j ACCEPT
            done
             
            for PORT in $UDP_SERVICES; do
                $IP6TABLES -A INPUT -p udp --dport ${PORT} -j ACCEPT
            done
             
        # Services à autoriser en sortie
         
            for PORT in $REMOTE_TCP_SERVICES; do
                $IP6TABLES -A OUTPUT -p tcp --dport ${PORT} -j ACCEPT
            done
            for PORT in $REMOTE_UDP_SERVICES; do
                $IP6TABLES -A OUTPUT -p udp --dport ${PORT} -j ACCEPT
            done
            # Parefeu - Mise en place des règles
         
            if $ISROUTERNAT ; then
                $IP6TABLES -A INPUT -i $ethx -j ACCEPT
                $IP6TABLES -A INPUT -p icmp -j ACCEPT
                $IP6TABLES -A FORWARD -i $ethy -o $ethx -m state --state RELATED,ESTABLISHED -j ACCEPT
                $IP6TABLES -A FORWARD -o $ethy -j ACCEPT
                $IP6TABLES -t nat -A POSTROUTING -o $ethy -j MASQUERADE
                $IP6TABLES -A INPUT -p icmpv6 --icmpv6-type router-solicitation -m hl --hl-eq 255 -j ACCEPT
                $IP6TABLES -A OUTPUT -p icmpv6 --icmpv6-type router-advertisement -j ACCEPT
            fi
             
            # Pour toute interface de type broadcast
            $IP6TABLES -A INPUT -p icmpv6 --icmpv6-type neighbour-solicitation -m hl --hl-eq 255 -j ACCEPT
            $IP6TABLES -A INPUT -p icmpv6 --icmpv6-type neighbour-advertisement -m hl --hl-eq 255 -j ACCEPT
            $IP6TABLES -A OUTPUT -p icmpv6 --icmpv6-type neighbour-solicitation -j ACCEPT
            $IP6TABLES -A OUTPUT -p icmpv6 --icmpv6-type neighbour-advertisement -j ACCEPT
   
   
        # Toutes les autres connexions sont enregistrées dans syslog
            $IP6TABLES -t filter -A INPUT -j LOG --log-level=4
        fi
    }
   
    fw_stop () {
        #$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
        $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
        if [ $IPV6 -eq 1 ]; then
            $IP6TABLES -t filter -F
            $IP6TABLES -t nat -F
            $IP6TABLES -t mangle -F
            $IP6TABLES -t raw -F
            $IP6TABLES -t filter -P INPUT ACCEPT
            $IP6TABLES -t filter -P OUTPUT ACCEPT
            $IP6TABLES -t filter -P FORWARD ACCEPT
            $IP6TABLES -t nat -P PREROUTING ACCEPT
            $IP6TABLES -t nat -P POSTROUTING ACCEPT
            $IP6TABLES -t nat -P OUTPUT ACCEPT
            $IP6TABLES -t mangle -P PREROUTING ACCEPT
            $IP6TABLES -t mangle -P OUTPUT ACCEPT
            $IP6TABLES -t mangle -P POSTROUTING ACCEPT
            $IP6TABLES -t mangle -P FORWARD ACCEPT
            $IP6TABLES -t mangle -P INPUT ACCEPT
            $IP6TABLES -t raw -P OUTPUT ACCEPT
            $IP6TABLES -t raw -P PREROUTING ACCEPT
            $IP6TABLES -F
        fi
    }
   
    fw_status () {
        $IPTABLES -L --line-numbers
        if [ $IPV6 -eq 1 ]; then
            $IP6TABLES -L --line-numbers
        fi
    }
   
    #----------------------------------------------------------------------#
   
    case "$1" in
        start|restart)
            log_daemon_msg "Starting firewall.."
            fw_start
            log_end_msg $?
        ;;
        stop)
            log_daemon_msg "Stopping firewall.."
            fw_stop
            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|stop|restart|clean|status}"
            exit 1
        ;;
    esac
    exit 0


== Ressources ==
== Ressources ==
PengouinPdt
editor, reviewer
416

modifications

Récupérée de « https://forum-debian.fr/wiki/Spécial:MobileDiff/3417...7121 »

Menu de navigation