bimdata.ferm

Aperçu Versions Perspectives

Rôle Ansible Ferm

Ce rôle installe et configure Ferm.

Exigences

  • Ce rôle est testé uniquement avec Ansible >= 2.9.

Variables du rôle

Vous pouvez trouver plus d'informations sur chaque option dans la documentation de Ferm.

Variables utilisées pour l'installation :

Variables Valeur par défaut Description
ferm_pkg_name ferm Nom du paquet APT pour ferm.
ferm_svc_name ferm Nom du service ferm à démarrer/arrêter.

Variables utilisées pour la configuration générale :

Variables Valeur par défaut Description
ferm_main_conf_file /etc/ferm/ferm.conf Chemin du fichier de configuration principal de Ferm.
ferm_rules_path /etc/ferm/ferm.d Chemin du répertoire des règles de Ferm.

Les règles par défaut seront stockées dans le fichier de configuration principal, qui chargera ensuite toutes les règles définies dans le répertoire de configuration. Cela vous permet de définir d'autres règles non gérées par ce rôle (si ferm_delete_unknown_rules est défini sur false).

Variable utilisée pour la configuration des règles :

Variables Valeur par défaut Description
ferm_delete_unknown_rulefiles true Supprimer les règles dans ferm_rules_path non gérées par ce rôle.
ferm_default_domains ['ip', 'ip6'] Lorsqu'une règle ne spécifie pas de domaine, celui-ci est utilisé.
ferm_default_table filter Lorsqu'une règle ne spécifie pas de table, celle-ci est utilisée.

Variable utilisée pour la définition des règles :

Variables Valeur par défaut Description
ferm_input_policy DROP Politique d'entrée par défaut de Ferm.
ferm_output_policy ACCEPT Politique de sortie par défaut de Ferm.
ferm_forward_policy DROP Politique de transfert par défaut de Ferm.
_ferm_rules "{{ lookup('template', 'get_vars.j2', template_vars=dict(vartype='rule')) }}" Liste de dictionnaires définissant toutes les règles de ferm.
_ferm_vars "{{ lookup('template', 'get_vars.j2', template_vars=dict(vartype='var')) }}" Liste de dictionnaires définissant toutes les variables de ferm.
_ferm_functions "{{ lookup('template', 'get_vars.j2', template_vars=dict(vartype='function')) }}" Liste de dictionnaires définissant toutes les fonctions de ferm.
_ferm_hooks "{{ lookup('template', 'get_vars.j2', template_vars=dict(vartype='hook')) }}" Liste de dictionnaires définissant tous les hooks de ferm.

Dans la plupart des cas, vous ne devez pas modifier les variables qui commencent par un '_'. Le templating est utilisé pour construire ces listes avec d'autres variables.

  • _ferm_rules regroupera toutes les variables dont le nom correspond à cette regex : ^ferm_.+_rule(s)?$
  • _ferm_vars regroupera toutes les variables dont le nom correspond à cette regex : ^ferm_.+_var(s)?$
  • _ferm_functions regroupera toutes les variables dont le nom correspond à cette regex : ^ferm_.+_function(s)?$
  • _ferm_hooks regroupera toutes les variables dont le nom correspond à cette regex : ^ferm_.+_hook(s)?$

Chaque variable correspondant à ces regex doit être :

  • un dictionnaire définissant une règle/variable/fonction/hook ou
  • une liste de dictionnaires définissant une ou plusieurs règles/variables/fonctions/hooks.

Cela vous permet de définir des variables dans plusieurs group_vars et de les cumuler pour des hôtes dans plusieurs groupes sans avoir à réécrire la liste complète.

Variables utilisées pour définir le jeux de règles par défaut :

  • celle-ci configure le jeux de règles par défaut pour la table INPUT :
    ferm_default_inputs:
  - "policy {{ ferm_input_policy }};"
  - interface lo ACCEPT;
  - "mod conntrack ctstate (RELATED ESTABLISHED) ACCEPT;"
  • celle-ci configure le jeux de règles par défaut pour la table OUTPUT :
    ferm_default_outputs:
  - "policy {{ ferm_output_policy }};"
  - interface lo ACCEPT;
  - "mod conntrack ctstate (RELATED ESTABLISHED) ACCEPT;"
  • celle-ci configure le jeux de règles par défaut pour la table FORWARD :
    ferm_default_forwards: []

Debian 11 utilise iptables-nft par défaut et ce n'est pas supporté par ferm. Depuis Debian 11, ferm ignore les paramètres alternatifs et force l’utilisation de iptables-legacy (https://github.com/MaxKellermann/ferm/issues/47)

Variables Valeur par défaut Description
ferm_iptables_path /usr/sbin/iptables-legacy Chemin de iptables-legacy.
ferm_ip6tables_path /usr/sbin/ip6tables-legacy Chemin de ip6tables-legacy.
ferm_arptables_path /usr/sbin/arptables-legacy Chemin de arptables-legacy.
ferm_ebtables_path /usr/sbin/ebtables-legacy Chemin de ebtables-legacy.

Ces variables ne sont utilisées que sur les hôtes Debian avec version > 10. Cela configurera le système d'exploitation avec le système alternative pour définir la valeur de ferm_iptables_path, ferm_ip6tables_path, ferm_arptables_path et ferm_ebtables_path comme commande iptables par défaut.

Définitions des variables

Une variable ferm peut être définie comme ceci :

ferm_webports_var:
  name: web_ports
  content:
    - 80
    - 443

ferm_hosts_vars:
  - name: web_front_addr
    content:
      - 172.29.10.100
      - 2a01:baaf::100

Définitions des hooks

Un hook ferm peut être défini comme ceci :

ferm_fail2ban_hooks:
  - comment: Hooks Fail2ban
    content: post "type fail2ban-server > /dev/null && (fail2ban-client ping > /dev/null && fail2ban-client reload > /dev/null || true) || true";
  - content: flush "type fail2ban-server > /dev/null && (fail2ban-client ping > /dev/null && fail2ban-client reload > /dev/null || true) || true";

Définitions des règles

Une règle peut être définie de deux manières :

ferm_web_rules:
  - name: "web_server"
    content:
      - domains: ['ip']        # Peut être omis, ferm_default_domains sera utilisé
        chains: ['INPUT']      # Peut être omis, ferm_default_table sera utilisé
        rules:
          - proto tcp dport ($web_ports) mod comment comment "serveur web" ACCEPT

ou vous pouvez définir des règles brutes :

ferm_web_rules:
  - name: "web_server"
    raw_content: |
      domaine (ip) table filter {
        chaîne (INPUT) {
          proto tcp dport ($web_ports) mod comment comment "serveur web" ACCEPT;
        }
      }

Définitions des fonctions

Une fonction ferm peut être définie comme ceci :

ferm_dnat_function:
  comment: "DNAT facile (règles DNAT+filter)"
  content: |
    @def &EASY_DNAT($wan_ip, $proto, $port, $dest) = {
      domaine ip table nat chaîne PREROUTING daddr $wan_ip proto $proto dport $port DNAT to @ipfilter($dest);
      domaine (ip ip6) table filter chaîne FORWARD outerface $dmz_iface daddr $dest proto $proto dport $port ACCEPT;
    }

Ensuite, vous devez utiliser une règle brute pour l'utiliser, quelque chose comme :

ferm_dnat_rules:
  - name: "80-dnat-rules"
    raw_content: |
      # HTTP(S) web_front
      &EASY_DNAT($main_public_ip, tcp, (80 443), $web_front_addr);

Exemple Docker

Docker et d'autres logiciels peuvent vouloir gérer leurs propres règles iptables. C'est possible, avec quelques limitations. Voici un exemple pour Docker :

# Aucune règle ne peut être définie dans FORWARD avant la règle pour préserver toutes
# les règles configurées par docker
ferm_default_forwards: []

# Préserver les règles de docker
ferm_docker_preserve_rules:
  - name: 99-docker-users.ferm
    content:
      - domains: ['ip']
        chains: ['DOCKER-USER']
        rules:
          - "RETURN;"
  - name: 00-docker-preserve.ferm
    content:
      - domains: ['ip']
        chains:
          - DOCKER
          - DOCKER-INGRESS
          - DOCKER-ISOLATION-STAGE-1
          - DOCKER-ISOLATION-STAGE-2
          - FORWARD
        rules:
          - "@preserve;"
      - domains: ['ip']
        table: nat
        chains:
          - DOCKER
          - DOCKER-INGRESS
          - PREROUTING
          - OUTPUT
          - POSTROUTING
        rules:
          - "@preserve;"

@preserve est un mot spécial utilisé par ferm. Il sauvegardera les règles précédentes avec iptables-save et extraira ensuite toutes les règles pour les chaînes préservées et les insérera dans les nouvelles règles.

Dépendances

Aucune

Exemple de Playbook

dans group_vars/all.yml :

ferm_webports_var:
  name: web_ports
  content:
    - 80
    - 443

dans group_vars/web.yml :

ferm_web_rules:
  - name: "web_server"
    content:
      - chains: ['INPUT']
        rules:
          - proto tcp dport ($web_ports) mod comment comment "serveur web" ACCEPT

dans group_vars/router.yml :

ferm_interface_vars:
  - name: wan_iface
    content: ['eth0']
  - name: dmz_iface
    content: ['eth1']
  - name: lan_iface
    content:
      - eth2
      - eth3

ferm_ips_vars:
  - name: main_public_ip
    content: ['1.2.3.4']
  - name: web_front_addr
    content:
      - 10.0.0.100
      - 2a01:baaf::100

ferm_dnat_function:
  comment: "DNAT facile (règles DNAT+filter)"
  content: |
    @def &EASY_DNAT($wan_ip, $proto, $port, $dest) = {
      domaine ip table nat chaîne PREROUTING daddr $wan_ip proto $proto dport $port DNAT to @ipfilter($dest);
      domaine (ip ip6) table filter chaîne FORWARD outerface $dmz_iface daddr $dest proto $proto dport $port ACCEPT;
    }

ferm_dnat_rules:
  - name: "80-dnat-rules"
    raw_content: |
      # HTTP(S) web_front
      &EASY_DNAT($main_public_ip, tcp, $web_ports, $web_front_addr);

dans playbook.yml :

- hosts: all
  gather_facts: True
  become: yes
  roles:
    - bimdata.ferm

Licence

BSD

Informations sur l'auteur

BIMData.io

À propos du projet

This role installs and configures ferm.

role ferm firewall iptables
Installer
ansible-galaxy install bimdata.ferm
GitHub référentiel
1 étoiles
0 forks
0 problèmes ouverts
Licence
mit
Téléchargements
45k
Propriétaire