Ansible Rolle: Firewall

Installieren und Konfigurieren einer Firewall (basierend auf nftables) auf Linux.

Voraussetzungen

Keine.

Rollenvariablen

Verfügbare Variablen sind unten aufgeführt, zusammen mit Standardwerten (siehe defaults\main.yaml)

NAT und Datenverkehrsweiterleitung aktivieren

• firewall_forward_enabled: Aktivieren oder Deaktivieren der Unterstützung für die Datenverkehrsweiterleitung auf einem bestimmten Host. [Standard: false].
• firewall_nat_enabled: Aktivieren oder Deaktivieren der NAT-Unterstützung auf einem bestimmten Host. [Standard: false].

Standardmäßig geöffnete Ports definieren

• in_tcp_port: Eingehender TCP-Datenverkehr ist über diese Ports erlaubt. [Standard: { ssh }].
• in_udp_port: Eingehender UDP-Datenverkehr ist über diese Ports erlaubt. [Standard: { snmp }].
• out_tcp_port: Ausgehender TCP-Datenverkehr ist über diese Ports erlaubt. [Standard: { http, https, ssh }].
• out_udp_port: Ausgehender UDP-Datenverkehr ist über diese Ports erlaubt. [Standard: { domain, bootps, ntp }].

Regeln-Dictionaries

Für jede Kette innerhalb der IP-Tabelle (input, output, forward) und NAT-Tabelle (nat-prerouting und nat-postrouting) werden nft-Regeln in Dictionaries gespeichert, die auf Gruppen- und Hostebene überschrieben werden können.

Variablen- und Definitionssätze sowie globale Regeln

Satz von Variablen und Definitionssätze, die von den verschiedenen Regelketten und den globalen Kettenregeln verwendet werden, die aus anderen Ketten mit der Regel jump global aufgerufen werden können.

define	sets	globale Kette
nft_define_default	nft_set_default	nft_global_default
nft_define_group	nft_set_group	nft_global_group_rules
nft_define_host	nft_set_host	nft_global_host_rules

IP-Tabellenregeln

Eingangs-Kette	Ausgangs-Kette	Weiterleitungs-Kette
nft_input_default_rules	nft_output_default_rules	nft_forward_default_rules
nft_input_group_rules	nft_output_group_rules	nft_forward_group_rules
nft_input_host_rules	nft_output_host_rules	nft_forward_host_rules

NAT-Tabellenregeln

Prerouting-Kette	Postrouting-Kette
nft_nat_default_prerouting_rules	nft_nat_default_postrouting_rules
nft_nat_group_prerouting_rules	nft_nat_group_postrouting_rules
nft_nat_host_prerouting_rules	nft_nat_host_postrouting_rules

Jeder Typ von Regel-Dictionaries wird zusammengeführt und die Regeln werden in alphabetischer Reihenfolge der Schlüssel angewendet (es werden 000 bis 999 als Präfix verwendet). Also:

• nft_*_default_rules: definiert Standardregeln für alle Knoten. Sie können dies in group_vars/all definieren.
• nft_*_group_rules: können Regeln hinzufügen und die von nft_*_default_rules und nft_*_rules definierten Regeln überschreiben. Sie können dies in group_vars/group_servers definieren.
• nft_*_host_rules: können Regeln hinzufügen und die von nft_*_default_rules, nft_*_group_rules und nft_*_rules definierten Regeln überschreiben. Sie können dies in host_vars/specific_host definieren.

Standard nvtables-Konfiguration

Standardmäßig generiert die Rolle die folgenden Konfigurationsdateien:

/etc/nftables.conf

#!/usr/sbin/nft -f
# Von Ansible verwaltet

# Bereinigen
flush ruleset

include "/etc/nftables.d/defines.nft"

table inet filter {
    chain global {
        # 000 Statusverwaltung
        ct state established,related accept
        ct state invalid drop
    }
    include "/etc/nftables.d/sets.nft"
    include "/etc/nftables.d/filter-input.nft"
    include "/etc/nftables.d/filter-output.nft"
}

/etc/nftables.d/defines.nft

  # Broadcast und Multicast
  define badcast_addr = { 255.255.255.255, 224.0.0.1, 224.0.0.251 }

  # Broadcast und Multicast
  define ip6_badcast_addr = { ff02::16 }

  # in_tcp_accept
  define in_tcp_accept = { ssh }

  # in_udp_accept
  define in_udp_accept = { snmp }

  # out_tcp_accept
  define out_tcp_accept = { http, https, ssh }

  # out_udp_accept
  define out_udp_accept = { domain, bootps, ntp }

/etc/nftables.d/sets.nft

  set blackhole {
        type ipv4_addr;
        elements = $badcast_addr
    }

  set in_tcp_accept {
        type inet_service; flags interval;
        elements = $in_tcp_accept
    }

  set in_udp_accept {
        type inet_service; flags interval;
        elements = $in_udp_accept
    }

  set ip6blackhole {
        type ipv6_addr;
        elements = $ip6_badcast_addr
    }

  set out_tcp_accept {
        type inet_service; flags interval;
        elements = $out_tcp_accept
    }

  set out_udp_accept {
        type inet_service; flags interval;
        elements = $out_udp_accept
    }

/etc/nftables.d/filter-input.nft

chain input {
        # 000 Richtlinie
        type filter hook input priority 0; policy drop;
        # 005 global
        jump global
        # 010 unerwünschte Pakete abweisen
        ip daddr @blackhole counter drop
        # 011 unerwünschte ipv6 abweisen
        ip6 daddr @ip6blackhole counter drop
        # 015 localhost
        iif lo accept
        # 050 icmp
        meta l4proto {icmp,icmpv6} accept
        # 200 eingehender UDP akzeptiert
        udp dport @in_udp_accept ct state new accept
        # 210 eingehender TCP akzeptiert
        tcp dport @in_tcp_accept ct state new accept
}

/etc/nftables.d/filter-output.nft

chain output {
        # 000 Richtlinie
        type filter hook output priority 0; policy drop;
        # 005 global
        jump global
        # 015 localhost
        oif lo accept
        # 050 icmp
        ip protocol icmp accept
        ip6 nexthdr icmpv6 counter accept
        # 200 ausgehender UDP akzeptiert
        udp dport @out_udp_accept ct state new accept
        # 210 ausgehender TCP akzeptiert
        tcp dport @out_tcp_accept ct state new accept
        # 250 reset-ssh
        tcp sport ssh tcp flags { rst, psh | ack } counter accept
}

Und das folgende Regelwerk auf dem Host (angezeigt durch Ausführen des Befehls nft list ruleset):

table inet filter {
        set blackhole {
                type ipv4_addr
                elements = { 224.0.0.1, 224.0.0.251,
                             255.255.255.255 }
        }

        set in_tcp_accept {
                type inet_service
                flags interval
                elements = { 22 }
        }

        set in_udp_accept {
                type inet_service
                flags interval
                elements = { 161 }
        }

        set ip6blackhole {
                type ipv6_addr
                elements = { ff02::16 }
        }

        set out_tcp_accept {
                type inet_service
                flags interval
                elements = { 22, 80, 443 }
        }

        set out_udp_accept {
                type inet_service
                flags interval
                elements = { 53, 67, 123 }
        }

        chain global {
                ct state established,related accept
                ct state invalid drop
        }

        chain input {
                type filter hook input priority filter; policy drop;
                jump global
                ip daddr @blackhole counter packets 0 bytes 0 drop
                ip6 daddr @ip6blackhole counter packets 0 bytes 0 drop
                iif "lo" accept
                meta l4proto { icmp, ipv6-icmp } accept
                udp dport @in_udp_accept ct state new accept
                tcp dport @in_tcp_accept ct state new accept
        }

        chain output {
                type filter hook output priority filter; policy drop;
                jump global
                oif "lo" accept
                ip protocol icmp accept
                ip6 nexthdr ipv6-icmp counter packets 0 bytes 0 accept
                udp dport @out_udp_accept ct state new accept
                tcp dport @out_tcp_accept ct state new accept
                tcp sport 22 tcp flags { rst, psh | ack } counter packets 0 bytes 0 accept
        }
}

Abhängigkeiten

Keine.

Beispiel-Playbooks

Standardregeln anwenden

Firewall auf einem Host mit Standardregeln installieren und konfigurieren

- hosts: serverx
  roles:
    - ricsanfre.firewall

In group_vars/all.yml können Sie die Standardregeln für alle Ihre Hosts überschreiben:

nft_input_default_rules:
  000 Richtlinie:
    - type filter hook input priority 0; policy drop;
  005 global:
    - jump global
  010 unerwünschte Pakete abweisen:
    - ip daddr @blackhole counter drop
  011 unerwünschte ipv6 abweisen:
    - ip6 daddr @ip6blackhole counter drop
  015 localhost:
    - iif lo accept
  050 icmp:
    - meta l4proto {icmp,icmpv6} accept
  200 eingehender UDP akzeptiert:
    - udp dport @in_udp_accept ct state new accept
  210 eingehender TCP akzeptiert:
    - tcp dport @in_tcp_accept ct state new accept

Standardregeln auf Gruppenebene ändern

Eingehenden HTTP-Datenverkehr für die Gruppe webservers öffnen:

In group_vars/webservers.yml kann dies durch Ändern von in_tcp_port erfolgen:

in_tcp_port: { ssh, http }

Oder durch Hinzufügen einer neuen spezifischen Regel

nft_input_group_rule:
  220 eingehender Internet-Zugriff akzeptiert:
    - tcp dport http ct state new accept

Standardeinstellungen + Gruppenregeln auf Host-Ebene ändern

Eingehenden HTTPS-Datenverkehr für den Host secureweb öffnen. In host_vars/secureweb.yml möchten Sie HTTPS öffnen und den Zugang zu HTTP entfernen:

nft_input_group_rule:
  220 eingehender Internet-Zugriff akzeptiert: []
  230 eingehender sicherer Datenverkehr akzeptiert:
    - tcp dport https ct state new accept

Standardeinstellungen können gelöscht werden

Um Regeln "zu löschen", weisen Sie einfach einer bestehenden Dictionarieschlüssel ein leeres Array zu: Beispiel: ICMP eingehenden Datenverkehr deaktivieren

nft_input_host_rules:
  050 icmp: []

Standardregeln zum Zulassen aller ausgehenden Daten zu entfernen. in einer bestimmten group_vars/group.yml

nft_output_group_rules:
  000 Richtlinie:
    - type filter hook output priority 0;
  005 global:
    -
  015 localhost:
    -
  050 icmp:
    -
  200 ausgehender UDP akzeptiert:
    -
  210 ausgehender TCP akzeptiert:
    -
  250 reset-ssh:
    -

000 Richtlinie wird überschrieben, um allen Datenverkehr zuzustimmen, und der Rest der Regeln wird entfernt.

Zusammenfassend werden Regeln in nft_X_host_rules die Regeln in nft_X_group_rules überschreiben, und dann werden Regeln in nft_X_group_rules die Regeln in nft_X_default_rules überschreiben.

Lizenz

MIT/BSD

Autorinformationen

Ricardo Sanchez (ricsanfre)