From aab25fb049bca1297bab056c04ada336e7952d4b Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Thu, 12 Nov 2026 12:15:10 +0100 Subject: [PATCH] fix(snmp): open udp/161 in firewalld, not behind it On a host running firewalld, iptables is installed too, so the SNMP fix inserted an iptables ACCEPT. firewalld keeps its own nftables table, whose reject wins over it, and the step reported the port open while SNMP stayed blocked. With firewalld active, the step now adds a rich rule per allowed source to the default zone (which takes interfaces in no zone, such as a WireGuard interface) and to every active zone, at runtime and permanently, each only when missing. No reload, which would drop rules others keep at runtime. Closes #77 --- CHANGELOG.md | 7 +++ napalm_linux/linux.py | 36 ++++++++++++++ tests/test_fix_templates.py | 95 +++++++++++++++++++++++++++++++++++-- 3 files changed, 134 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6b018ee..2970860 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -35,6 +35,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Changed - Needs napalm-device-types 4.35.0. +### Fixed +- `configure_snmp_agent()` opens udp/161 on a host running firewalld (Oracle Linux, RHEL, + Fedora): a rich rule per allowed source in the default zone and every active zone, at + runtime and permanently, without a reload. It used to insert an iptables rule there, + which firewalld's own reject overrides, so the fix reported the port open while SNMP + stayed blocked (#77). + ## [0.17.0] - 2026-11-04 ### Added diff --git a/napalm_linux/linux.py b/napalm_linux/linux.py index 5e551d5..8e0d119 100644 --- a/napalm_linux/linux.py +++ b/napalm_linux/linux.py @@ -277,6 +277,37 @@ def _source(value: str) -> str: return str(ipaddress.ip_network(value.strip(), strict=False)) +#: The zones a firewalld rule must reach: the default one, which takes every interface +#: in no zone (a WireGuard ``wg0``), and each zone holding an interface or a source. +_FIREWALLD_ZONES = ( + "$( { firewall-cmd --get-default-zone;" + " firewall-cmd --get-active-zones | grep -v '^[[:space:]]'; } | sort -u )" +) + + +def firewalld_allow_snmp(sources: list[str]) -> str: + """The shell that opens udp/161 for *sources* (already normalised) in firewalld. + + A rich rule per source in every zone of ``_FIREWALLD_ZONES``, at runtime and + permanently, each only when the zone lacks it -- no ``--reload``, which would drop + the runtime rules others (Docker) put there. + """ + steps = [] + for source in sources: + family = f"ipv{ipaddress.ip_network(source).version}" + rule = _shlex_quote( + f'rule family="{family}" source address="{source}"' + ' port port="161" protocol="udp" accept' + ) + for scope in ("", "--permanent "): + zone = f'firewall-cmd {scope}--zone="$z"' + steps.append( + f"{{ {zone} --query-rich-rule={rule} >/dev/null 2>&1" + f" || {zone} --add-rich-rule={rule}; }}" + ) + return f"for z in {_FIREWALLD_ZONES}; do {' && '.join(steps)} || exit 1; done" + + def render_snmpd_conf(settings: SnmpAgentSettingsDict) -> str: """net-snmp's configuration for *settings*: read-only v2c, per allowed source.""" community = settings["community"] @@ -1834,6 +1865,11 @@ class LinuxDriver( sources = [_source(s) for s in settings.get("allowed_sources", [])] if not sources: return {"ok": True, "output": "no sources given; firewall unchanged"} + # firewalld first: its hosts have iptables too, and an iptables ACCEPT does + # not lift firewalld's reject (both are nftables tables; a drop in either wins). + if self._send("systemctl is-active firewalld 2>/dev/null") == "active": + done = f"udp/161 open in firewalld for {', '.join(sources)}" + return self._root_outcome(firewalld_allow_snmp(sources), 60, done) if self._send("command -v ufw 2>/dev/null"): rules = [f"ufw allow from {s} to any port 161 proto udp" for s in sources] elif self._send("command -v iptables 2>/dev/null"): diff --git a/tests/test_fix_templates.py b/tests/test_fix_templates.py index 8f1dd3d..1685506 100644 --- a/tests/test_fix_templates.py +++ b/tests/test_fix_templates.py @@ -69,17 +69,22 @@ def driver(): class TestSnmpAgentSteps: SETTINGS = {"community": "c0mm", "allowed_sources": ["10.0.0.5"]} - def _record(self, driver, status=0, firewall="ufw"): + def _record(self, driver, status=0, firewall="ufw", firewalld=False): ran: list[str] = [] def sudo_status(command, read_timeout=100): ran.append(command) return ("", status) + def send(command, read_timeout=100): + if command == "systemctl is-active firewalld 2>/dev/null": + return "active" if firewalld else "inactive" + return ( + f"/usr/sbin/{firewall}" if command == f"command -v {firewall} 2>/dev/null" else "" + ) + driver._sudo_status = sudo_status - driver._send = lambda command, read_timeout=100: ( - f"/usr/sbin/{firewall}" if command == f"command -v {firewall} 2>/dev/null" else "" - ) + driver._send = send driver._install_file_as_root = MagicMock( return_value=MagicMock(exit_code=0, stdout="", stderr="") ) @@ -105,6 +110,88 @@ class TestSnmpAgentSteps: assert "iptables -I INPUT -s 10.0.0.5/32 -p udp --dport 161 -j ACCEPT" in ran[1] + def test_a_running_firewalld_gets_a_rich_rule_not_an_iptables_one(self, driver): + """An iptables ACCEPT does not lift firewalld's reject: with nftables both + tables see the packet, and the drop in either wins (Oracle Linux, RHEL).""" + ran = self._record(driver, firewall="iptables", firewalld=True) + + result = driver.configure_snmp_agent(self.SETTINGS) + + assert result["success"] is True + assert "iptables" not in ran[1] + assert ( + 'rule family="ipv4" source address="10.0.0.5/32" port port="161" protocol="udp" accept' + ) in ran[1] + assert "--permanent" in ran[1] + assert "--reload" not in ran[1] + + def test_the_firewalld_rule_goes_to_the_default_and_every_active_zone(self, tmp_path): + """An interface in no zone (a WireGuard wg0) is the default zone's; one in a + zone of its own is that zone's. The rule goes in now and stays after a reload.""" + from napalm_linux.linux import firewalld_allow_snmp + + log = tmp_path / "calls" + fake = tmp_path / "firewall-cmd" + fake.write_text( + "#!/bin/sh\n" + f'echo "$*" >> {log}\n' + 'case "$*" in\n' + " --get-default-zone) echo public ;;\n" + ' --get-active-zones) printf "docker\\n interfaces: docker0\\n' + 'public\\n interfaces: enp0s6\\n" ;;\n' + " *--query-rich-rule*) exit 1 ;;\n" + "esac\n" + ) + fake.chmod(0o755) + + import os + import subprocess + + done = subprocess.run( + ["sh", "-c", firewalld_allow_snmp(["10.0.0.5/32", "fd00::/64"])], + env={**os.environ, "PATH": f"{tmp_path}:{os.environ['PATH']}"}, + capture_output=True, + text=True, + ) + + assert done.returncode == 0, done.stdout + done.stderr + adds = [line for line in log.read_text().splitlines() if "--add-rich-rule" in line] + v4 = 'rule family="ipv4" source address="10.0.0.5/32" port port="161" protocol="udp" accept' + v6 = 'rule family="ipv6" source address="fd00::/64" port port="161" protocol="udp" accept' + for zone in ("public", "docker"): + for rule in (v4, v6): + assert f"--zone={zone} --add-rich-rule={rule}" in adds + assert f"--permanent --zone={zone} --add-rich-rule={rule}" in adds + assert len(adds) == 8 + + def test_a_rule_firewalld_holds_already_is_not_added_twice(self, tmp_path): + from napalm_linux.linux import firewalld_allow_snmp + + log = tmp_path / "calls" + fake = tmp_path / "firewall-cmd" + fake.write_text( + "#!/bin/sh\n" + f'echo "$*" >> {log}\n' + 'case "$*" in\n' + " --get-default-zone) echo public ;;\n" + " --get-active-zones) ;;\n" + "esac\n" + ) + fake.chmod(0o755) + + import os + import subprocess + + done = subprocess.run( + ["sh", "-c", firewalld_allow_snmp(["10.0.0.5/32"])], + env={**os.environ, "PATH": f"{tmp_path}:{os.environ['PATH']}"}, + capture_output=True, + text=True, + ) + + assert done.returncode == 0 + assert "--add-rich-rule" not in log.read_text() + def test_no_sources_change_no_firewall(self, driver): ran = self._record(driver)