From 6ecf8edb132cef808e7eadb07bb32eca3583043c Mon Sep 17 00:00:00 2001 From: Navid Sassan Date: Fri, 13 Nov 2026 17:48:04 +0100 Subject: [PATCH] fix(roles/firewall)!: make the iptables and nftables rulesets mandatory (fix #721) The role deployed no nftables ruleset, and what the packages ship filters nothing: comments only on the Red Hat family, three chains with policy accept on Debian and Ubuntu. Since the role stops every other firewall, the host ended up unfiltered. For iptables the ruleset was optional and came from a fixed path in host_files. Both now come from a variable, firewall__iptables_ruleset and firewall__nftables_ruleset, and the preflight aborts if the one for the selected firewall is unset. The ruleset is validated and deployed before the other firewalls are stopped, so a broken one aborts the run with the old firewall still running. --- CHANGELOG.md | 1 + .../group_vars/systems_under_test.yml | 11 +++ extensions/molecule/firewall/tasks/abort.yml | 23 +++++ extensions/molecule/firewall/verify.yml | 92 ++++++++++++++++++- roles/firewall/README.md | 29 +++++- roles/firewall/tasks/main.yml | 89 ++++++++++++------ roles/firewall/tasks/preflight.yml | 18 ++++ roles/firewall/vars/main.yml | 4 + 8 files changed, 236 insertions(+), 31 deletions(-) create mode 100644 extensions/molecule/firewall/tasks/abort.yml diff --git a/CHANGELOG.md b/CHANGELOG.md index 73ac03296..f9d0f2905 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Breaking Changes +* **role:firewall**: With `firewall__firewall: 'iptables'` or `'nftables'`, the ruleset is mandatory and comes from `firewall__iptables_ruleset` or `firewall__nftables_ruleset`; without it, the run aborts before the role stops any firewall. Until now an nftables host ended up without any filtering unless a ruleset was deployed by other means, and iptables hosts kept whatever `/etc/sysconfig/iptables` held. The role no longer picks up `host_files//etc/sysconfig/iptables` on its own: set `firewall__iptables_ruleset` to a `lookup("ansible.builtin.file", ...)` of that file, as the role README shows, and on nftables hosts move the ruleset into `firewall__nftables_ruleset`. * **role:sshd, playbook:setup_basic**: sshd turns new connections away earlier while many logins are pending (`MaxStartups 10:30:60` instead of the OpenSSH default `10:30:100`), as the CIS Benchmarks require, and `MaxStartups` is configurable with `sshd__max_startups__host_var` / `sshd__max_startups__group_var`. A `MaxStartups` set through `sshd__raw` no longer takes effect, move it to the variable. Hosts with many simultaneous SSH logins need a higher value, for example `'100:30:200'` on GitLab hosts ([#723](https://github.com/Linuxfabrik/lfops/issues/723)). * **role:grav, playbook:setup_grav**: The code of Grav, its configuration, pages, plugins and themes belong to `root`, so a hole in Grav or a plugin can no longer plant code in the site. The web server only writes `assets`, `backup`, `cache`, `images`, `logs`, `tmp`, `user/accounts` and `user/data`, and only these keep the SELinux type `httpd_sys_rw_content_t`. Grav, its plugins and themes are updated as `root` by `grav-selfupgrade-.timer` and `grav-update-.timer`, which replace `grav-selfupgrade.timer` and `grav-update.timer`, so several Grav sites on one host are each updated. Run other `bin/gpm` commands with `grav-gpm ` instead of `sudo -u apache bin/gpm`, which now fails, and deploy content below `user/` as `root`. The role no longer installs the Admin Panel, which could not save anything anymore, and drops `grav__skip_admin` and `grav__users`; it lists the Admin Panel plugins still installed at the end of the play, for you to remove. The vHost no longer accepts `POST`, and `setup_grav` no longer sets the SELinux boolean `httpd_can_network_connect`, which keeps its current value. * **role:apache_httpd**: The `proxy` vHost template waits 30 instead of 5 seconds for the backend, so slower responses no longer end in a 502, and a hanging backend holds the connection longer. Set `conf_proxy_timeout: 5` on the vHost to keep the previous value. diff --git a/extensions/molecule/firewall/inventory/group_vars/systems_under_test.yml b/extensions/molecule/firewall/inventory/group_vars/systems_under_test.yml index 3103cf752..f31308810 100644 --- a/extensions/molecule/firewall/inventory/group_vars/systems_under_test.yml +++ b/extensions/molecule/firewall/inventory/group_vars/systems_under_test.yml @@ -2,3 +2,14 @@ # has to stop, disable and mask fwb.service, and the idempotence step proves that masking the # unit the role deployed itself does not report a change on every run. firewall__firewall: 'nftables' + +# The policy stays accept, so the VM remains reachable. The rule on a port nothing uses is what +# verify.yml looks for in the kernel. +firewall__nftables_ruleset: |- + flush ruleset + table inet lfops_molecule { + chain input { + type filter hook input priority filter; policy accept; + tcp dport 65000 counter drop + } + } diff --git a/extensions/molecule/firewall/tasks/abort.yml b/extensions/molecule/firewall/tasks/abort.yml new file mode 100644 index 000000000..1c44e28ae --- /dev/null +++ b/extensions/molecule/firewall/tasks/abort.yml @@ -0,0 +1,23 @@ +# Included by verify.yml once per case in which the role has to abort: runs the role with the +# firewall and ruleset of `__molecule__abort` and checks which task failed. +- block: + + - name: 'Run the firewall role' + ansible.builtin.include_role: + name: 'linuxfabrik.lfops.firewall' + vars: + firewall__firewall: '{{ __molecule__abort["firewall"] }}' + firewall__iptables_ruleset: '{{ __molecule__abort["ruleset"] }}' + firewall__nftables_ruleset: '{{ __molecule__abort["ruleset"] }}' + + - name: 'Fail, since the role did not abort' + ansible.builtin.fail: + msg: 'The firewall role did not abort.' + + rescue: + + - name: 'Assert that the role failed where expected, not on the task above' + ansible.builtin.assert: + that: + - 'ansible_failed_task["name"] is search(__molecule__abort["failed_task"])' + fail_msg: '{{ ansible_failed_task["name"] }}: {{ ansible_failed_result["msg"] | d("") }}' diff --git a/extensions/molecule/firewall/verify.yml b/extensions/molecule/firewall/verify.yml index 72ccf1323..3b5db44e0 100644 --- a/extensions/molecule/firewall/verify.yml +++ b/extensions/molecule/firewall/verify.yml @@ -1,6 +1,6 @@ -- name: 'Verify the switch from fwbuilder to nftables, and the abort on a repository without a compiled firewall' +- name: 'Verify the switch from fwbuilder to nftables, the way to iptables and back, and the aborts without a ruleset and on a repository without a compiled firewall' hosts: 'systems_under_test' - gather_facts: false + gather_facts: true # the role needs the os_family tasks: @@ -27,6 +27,94 @@ - '__molecule__fwb_is_enabled_result["stdout"] == "masked"' fail_msg: '{{ __molecule__is_active_result["stdout_lines"] + [__molecule__fwb_is_enabled_result["stdout"]] }}' + # nftables.service has to load the ruleset from the inventory into the kernel. + - name: 'nft list table inet lfops_molecule' + ansible.builtin.command: 'nft list table inet lfops_molecule' + changed_when: false + register: '__molecule__nft_list_result' + + - name: 'Assert that the ruleset is loaded' + ansible.builtin.assert: + that: + - '"tcp dport 65000 counter" in __molecule__nft_list_result["stdout"]' + fail_msg: '{{ __molecule__nft_list_result["stdout_lines"] }}' + + # Without a ruleset in the inventory the role must abort in its preflight checks. + - name: 'Run the firewall role without a ruleset' + ansible.builtin.include_tasks: 'tasks/abort.yml' + loop: + - firewall: 'iptables' + ruleset: '' + failed_task: 'has a ruleset for' + - firewall: 'nftables' + ruleset: " \n" + failed_task: 'has a ruleset for' + # a ruleset nft rejects must not replace the file nftables.service loads + - firewall: 'nftables' + ruleset: 'table inet lfops_molecule_broken {' + failed_task: 'Deploy ' + loop_control: + loop_var: '__molecule__abort' + label: '{{ __molecule__abort["firewall"] }}: {{ __molecule__abort["ruleset"] | trim }}' + + - name: 'nft list ruleset (after the aborted runs)' + ansible.builtin.command: 'nft list ruleset' + changed_when: false + register: '__molecule__nft_list_after_abort_result' + + - name: 'Assert that the ruleset from the inventory is still the one loaded' + ansible.builtin.assert: + that: + - '"tcp dport 65000 counter" in __molecule__nft_list_after_abort_result["stdout"]' + - '"lfops_molecule_broken" not in __molecule__nft_list_after_abort_result["stdout"]' + fail_msg: '{{ __molecule__nft_list_after_abort_result["stdout_lines"] }}' + + # The way to iptables and back, on the Red Hat family, which has the iptables-services + # package: iptables.service has to load the ruleset from the inventory, and nftables has to be + # stopped. The second run restores the state the idempotence step and this play start from. + - name: 'stat /etc/redhat-release' + ansible.builtin.stat: + path: '/etc/redhat-release' + register: '__molecule__redhat_release_result' + + - block: + + - name: 'Run the firewall role with iptables' + ansible.builtin.include_role: + name: 'linuxfabrik.lfops.firewall' + vars: + firewall__firewall: 'iptables' + firewall__iptables_ruleset: |- + *filter + :INPUT ACCEPT [0:0] + :FORWARD ACCEPT [0:0] + :OUTPUT ACCEPT [0:0] + -A INPUT -p tcp -m tcp --dport 65001 -j DROP + COMMIT + + - name: 'systemctl is-active iptables.service nftables.service; iptables-save' # noqa command-instead-of-module (read-only state query) + ansible.builtin.shell: 'systemctl is-active iptables.service nftables.service; iptables-save' + changed_when: false + register: '__molecule__iptables_result' + + - name: 'Assert that iptables.service loaded the ruleset and nftables.service is stopped' + ansible.builtin.assert: + that: + - '__molecule__iptables_result["stdout_lines"][:2] == ["active", "inactive"]' + - '__molecule__iptables_result["stdout"] is search("--dport 65001 -j DROP")' + fail_msg: '{{ __molecule__iptables_result["stdout_lines"] }}' + + - name: 'Run the firewall role with nftables again' + ansible.builtin.include_role: + name: 'linuxfabrik.lfops.firewall' + + - name: 'nft list table inet lfops_molecule (back on nftables)' + ansible.builtin.command: 'nft list table inet lfops_molecule' + changed_when: false + + when: + - '__molecule__redhat_release_result["stat"]["exists"]' + # A Firewall Builder repository without a compiled firewall for the host must abort the run # before the role stops the firewall that is running, here nftables. - name: 'mktemp -d (empty Firewall Builder repository on the controller)' diff --git a/roles/firewall/README.md b/roles/firewall/README.md index 1f907158e..76165a8c1 100644 --- a/roles/firewall/README.md +++ b/roles/firewall/README.md @@ -11,7 +11,7 @@ This role configures a firewall on the system. For the currently supported firew Manual steps: * When using `firewall__firewall == fwbuilder`, either manually deploy a Firewall Builder file to `/etc/fwb.sh` or use the ``firewall__fwbuilder_repo_url`` variable to clone the Firewall Builder files automatically. Without either, or if the repository has no compiled file for the host, the run aborts before the role stops any firewall. -* When using `firewall__firewall == iptables`, optionally place an iptables config file in your inventory, which will be deployed to the system. The file has to be placed into `{{ inventory_dir }}/host_files/{{ inventory_hostname }}/etc/sysconfig/iptables`. +* When using `firewall__firewall == iptables` or `firewall__firewall == nftables`, set the ruleset in `firewall__iptables_ruleset` or `firewall__nftables_ruleset`. Without it, the run aborts before the role stops any firewall. ## Tags @@ -90,6 +90,18 @@ Manual steps: * Type: String. * Default: unset +`firewall__iptables_ruleset` + +* The iptables ruleset in `iptables-save` format, deployed to `/etc/sysconfig/iptables`. Mandatory if `firewall__firewall` is `'iptables'`. The role checks it with `iptables-restore --test` before it replaces the file, and restarts `iptables.service` after a change. +* Type: String. +* Default: unset + +`firewall__nftables_ruleset` + +* The nftables ruleset, deployed to the file `nftables.service` loads: `/etc/sysconfig/nftables.conf` on the Red Hat family, `/etc/nftables.conf` on Debian and Ubuntu. Mandatory if `firewall__firewall` is `'nftables'`. The role checks it with `nft --check` before it replaces the file, and restarts `nftables.service` after a change. +* Type: String. +* Default: unset + Example: ```yaml # optional @@ -104,6 +116,21 @@ firewall__firewalld_services__host_var: state: 'enabled' firewall__fwbuilder_fw_file: 'example' firewall__fwbuilder_repo_url: 'git@git.example.com:fwbuilder/fwb.git' +# from a file in the inventory +firewall__iptables_ruleset: '{{ lookup("ansible.builtin.file", + inventory_dir ~ "/host_files/" ~ inventory_hostname ~ "/etc/sysconfig/iptables") + }}' +firewall__nftables_ruleset: |- + flush ruleset + table inet filter { + chain input { + type filter hook input priority filter; policy drop; + ct state established,related accept + iif "lo" accept + meta l4proto { icmp, ipv6-icmp } accept + tcp dport 22 accept + } + } ``` diff --git a/roles/firewall/tasks/main.yml b/roles/firewall/tasks/main.yml index ad7c3d74b..4db512804 100644 --- a/roles/firewall/tasks/main.yml +++ b/roles/firewall/tasks/main.yml @@ -2,6 +2,63 @@ ansible.builtin.import_tasks: 'preflight.yml' +# Deployed before the other firewalls are stopped: `validate` rejects a broken ruleset, and the +# run then aborts with the firewall the host uses still running. Installing the packages does +# not start their services. +- block: + + - name: 'Make sure iptables-services is installed' + ansible.builtin.package: + name: 'iptables-services' + state: 'present' + retries: 3 # ride out a brief outage of the package repository + delay: 10 + + # the block scalar adds the newline iptables-restore needs after the last COMMIT, and which + # a file lookup strips + - name: 'Deploy /etc/sysconfig/iptables' + ansible.builtin.copy: + backup: true + content: | + {{ firewall__iptables_ruleset | trim }} + dest: '/etc/sysconfig/iptables' + owner: 'root' + group: 'root' + mode: 0o600 + validate: 'iptables-restore --test %s' + register: 'firewall__iptables_definition_result' + + when: 'firewall__firewall == "iptables"' + tags: + - 'firewall' + + +- block: + + - name: 'Make sure nftables is installed' + ansible.builtin.package: + name: 'nftables' + state: 'present' + retries: 3 # ride out a brief outage of the package repository + delay: 10 + + - name: 'Deploy {{ __firewall__nftables_conf }}' + ansible.builtin.copy: + backup: true + content: | + {{ firewall__nftables_ruleset | trim }} + dest: '{{ __firewall__nftables_conf }}' + owner: 'root' + group: 'root' + mode: 0o600 + validate: 'nft --check --file %s' + register: '__firewall__nftables_ruleset_result' + + when: 'firewall__firewall == "nftables"' + tags: + - 'firewall' + + - block: - name: 'Get the list of services' @@ -208,26 +265,6 @@ - block: - - name: 'Make sure iptables-services is installed' - ansible.builtin.package: - name: 'iptables-services' - state: 'present' - retries: 3 # ride out a brief outage of the package repository - delay: 10 - - - name: 'Copy iptables definition to /etc/sysconfig/iptables' - ansible.builtin.copy: - backup: true - src: "{{ inventory_dir }}/host_files/{{ inventory_hostname }}/etc/sysconfig/iptables" - dest: '/etc/sysconfig/' - owner: 'root' - group: 'root' - mode: 0o600 - # the parentheses are needed: `is` binds tighter than `~`, and without them the condition is a - # non-empty string that is always true - when: '(inventory_dir ~ "/host_files/" ~ inventory_hostname ~ "/etc/sysconfig/iptables") is file' - register: 'firewall__iptables_definition_result' - - name: 'systemctl restart iptables.service' ansible.builtin.systemd: name: 'iptables.service' @@ -243,17 +280,13 @@ - block: - - name: 'Make sure nftables is installed' - ansible.builtin.package: - name: 'nftables' - state: 'present' - retries: 3 # ride out a brief outage of the package repository - delay: 10 - + # Restarted rather than reloaded after a change: stopping the unit flushes the ruleset on every + # platform, while the reload on Debian and Ubuntu only loads the file again, which adds to the + # loaded ruleset unless the file starts with `flush ruleset`. - name: 'Be sure nftables is started, enabled and not masked' ansible.builtin.systemd: name: 'nftables.service' - state: 'started' + state: '{{ __firewall__nftables_ruleset_result is changed | bool | ternary("restarted", "started") }}' enabled: true masked: false diff --git a/roles/firewall/tasks/preflight.yml b/roles/firewall/tasks/preflight.yml index 44cdb701b..0fe8f5fa9 100644 --- a/roles/firewall/tasks/preflight.yml +++ b/roles/firewall/tasks/preflight.yml @@ -72,3 +72,21 @@ tags: - 'firewall' - 'firewall:deploy_fwb_sh' + + +# The role stops and masks every other firewall. iptables.service and nftables.service only load +# the ruleset they find on the host, and what the nftables packages ship filters nothing, so the +# ruleset has to come from the inventory. +- name: 'Assert that the inventory has a ruleset for {{ firewall__firewall }}' + ansible.builtin.assert: + that: + - 'lookup("ansible.builtin.vars", "firewall__" ~ firewall__firewall ~ "_ruleset", default="") | trim | length > 0' + quiet: true + fail_msg: >- + firewall__firewall is '{{ firewall__firewall }}', but firewall__{{ firewall__firewall }}_ruleset + is not set, so the host would run without the rules it needs. Set the variable to the + ruleset, or set firewall__firewall to the firewall this host uses. + when: + - 'firewall__firewall in ["iptables", "nftables"]' + tags: + - 'firewall' diff --git a/roles/firewall/vars/main.yml b/roles/firewall/vars/main.yml index 37c250a42..c805eafca 100644 --- a/roles/firewall/vars/main.yml +++ b/roles/firewall/vars/main.yml @@ -1,2 +1,6 @@ # The controller-side clone of firewall__fwbuilder_repo_url, one per repository. __firewall__fwbuilder_repo_dir: '/tmp/ansible.fwb-{{ firewall__fwbuilder_repo_url | d("") | hash("sha1") }}' + +# The file nftables.service loads, as its unit says (`ExecStart=... nft -f `). Verified with +# nftables 1.0.4 to 1.1.5 on Rocky 8, 9 and 10, Debian 12 and 13 and Ubuntu 24.04. +__firewall__nftables_conf: '{{ (ansible_facts["os_family"] == "RedHat") | ternary("/etc/sysconfig/nftables.conf", "/etc/nftables.conf") }}'