Files
napalm-bsd/napalm_bsd/freebsd.py
T
Christian Manivong faa5f24182
driver / standard (pull_request) Successful in 16s
driver / lint (pull_request) Successful in 16s
driver / types (pull_request) Failing after 1m5s
driver / test (3.13) (pull_request) Failing after 55s
driver / test (3.12) (pull_request) Failing after 1m1s
driver / lowest (pull_request) Failing after 30s
driver / build (pull_request) Successful in 32s
driver / security (pull_request) Successful in 1m30s
CI / driver (pull_request) Failing after 3m1s
driver / publish (pull_request) Skipped
feat: personal accounts on FreeBSD with pw and chpass (NetOrk/netork#1793)
FreeBSDDriver mixes in napalm-device-types' LocalAccountsMixin: pw useradd
-m -w no, chpass -p for the password hash, pw lock/unlock and pw groupmod
-d. A locked account carries *LOCKED*, which sshd refuses a key login too
(nuageinit sets UsePAM no, so nothing else would). getpwnam(3) shows the
password field to root only, so the lock is read with getent as root and
only its prefix is looked at. The sudo rule goes to the sudo package's
/usr/local/etc/sudoers.d.

Checked on a FreeBSD 15.1 cloud image with the real driver over SSH and
sudo -S: key login works after adding and after reopening and is refused
after locking, sudo takes the person's password, wheel is left when sudo
is not wanted. OpenBSD is left out for now.

CI pre-installs napalm-device-types from main until the release with
LocalAccountsMixin is on PyPI.
2026-10-31 23:32:01 +01:00

130 lines
5.5 KiB
Python

"""FreeBSD: kenv for the hardware, freebsd-version for base and kernel."""
from __future__ import annotations
from napalm_device_types import FingerprintRule
from napalm_bsd import parse
from napalm_bsd.accounts import FreeBSDLocalAccountsMixin
from napalm_bsd.base import BASE_SYSTEM, BsdDriver
class FreeBSDDriver(FreeBSDLocalAccountsMixin, BsdDriver):
"""NAPALM driver for FreeBSD hosts, over SSH."""
TYPE_LABEL = "FreeBSD"
VENDOR = "FreeBSD"
DRIVER_NAME = "freebsd"
SNMP_FINGERPRINT = [FingerprintRule("freebsd", weight=5.0)]
# OpenSSH in FreeBSD's base names it in its banner ("OpenSSH_9.9 FreeBSD-20250219").
SSH_FINGERPRINT = [FingerprintRule("freebsd", weight=3.0)]
HOSTNAME_COMMAND = "sysctl -n kern.hostname"
# Userland and running kernel; both carry the patch level (15.1-RELEASE-p4).
OS_VERSION_COMMAND = "freebsd-version -u"
KERNEL_COMMAND = "freebsd-version -r"
# kenv takes one variable per call, and a missing one fails the call.
PLATFORM_COMMAND = (
"for k in maker product serial; do "
'printf "%s=%s\\n" "$k" "$(kenv -q smbios.system.$k)"; done'
)
# -W: FreeBSD cuts long destinations to the column width otherwise.
ROUTES_COMMAND = "netstat -rnW"
# sockstat names the process of every socket it can see; root sees them all.
LISTENING_COMMAND = "sockstat -46lq -P tcp,udp"
# /etc/rc removes it at the end of the first boot.
FIRST_BOOT_MARKER = "/firstboot"
def _parse_listening(self, output: str, *, attributed: bool) -> list[dict]:
return parse.sockstat(output)
PKG_QUERY = "pkg query '%n\t%v\t%R\t%sb\t%c'"
# Bootstraps pkg on a classic system that never had it, instead of asking.
INSTALL_COMMAND = "env ASSUME_ALWAYS_YES=yes pkg install -y {name}"
UNINSTALL_COMMAND = "pkg delete -y {name}"
# Root reads every daemon's pidfile; one-shot scripts have no status.
SERVICE_STATUS_COMMAND = (
"for s in $(service -e); do n=${s##*/}; "
'printf "%s\\t%s\\n" "$n" "$(service $n status 2>&1 | head -1)"; done'
)
SERVICE_ACTION_COMMAND = "service {name} {action}"
SNMPD_CONF = "/usr/local/etc/snmp/snmpd.conf"
# The rc script drops to the snmpd user, so the file stays readable (644).
SNMPD_START = "sysrc snmpd_enable=YES && service snmpd restart"
def _parse_services(self, output: str) -> list[dict]:
return parse.service_status(output)
def _has_pkg(self) -> bool:
"""pkg is bootstrapped; a hand-installed classic system may have only the stub.
Only the stub's "not installed" means no pkg; any other failure (a
database pkg cannot read) raises rather than read as "no packages".
"""
result = self.run_command("pkg -N")
if result.exit_code == 0:
return True
message = (result.stderr or result.stdout).strip()
if "is not installed" in message:
return False
raise RuntimeError(f"pkg -N: {message or f'exit {result.exit_code}'}")
def get_packages(self) -> list[dict]:
return parse.pkg_query(self._out(self.PKG_QUERY)) if self._has_pkg() else []
def get_available_updates(self) -> list[dict]:
"""Package updates from ``pkg upgrade -n``, and fetched base-system updates.
``security`` comes from VuXML (``pkg audit``): True for a package it
lists as vulnerable, False for one it does not, None when the audit
could not run. On pkgbase the base system is packages from the
FreeBSD-base repository; a classic base reports one entry (#799).
"""
updates: list[dict] = []
if self._has_pkg():
upgrade = self._read("pkg upgrade -n", privileged=True, timeout=300)
updates = parse.pkg_upgrades(upgrade.stdout)
audit = self.run_command("pkg audit -Fq", privileged=True, timeout=120)
vulnerable = parse.pkg_audit(audit.stdout)
# 1 is "vulnerable packages found" and any error alike; only a list
# of packages makes it a verdict.
known = audit.exit_code == 0 or (audit.exit_code == 1 and bool(vulnerable))
for update in updates:
update["security"] = (update["name"] in vulnerable) if known else None
if "FreeBSD-base" in self._out("pkg repos -l").split():
return updates
return updates + self._base_updates()
def _base_updates(self) -> list[dict]:
"""A classic base system's updates, as freebsd-update fetched them.
``updatesready`` exits 0 when fetched updates wait to be installed and
2 when there are none; it does not fetch, which ``freebsd-update cron``
does daily where it is enabled.
"""
ready = self._read(
"freebsd-update --not-running-from-cron updatesready",
privileged=True,
timeout=60,
ok=(0, 2),
)
if ready.exit_code == 2:
return []
return [
{
"name": BASE_SYSTEM,
"current_version": self._out("freebsd-version -u"),
"new_version": "fetched by freebsd-update",
"origin": "freebsd-update",
"security": None,
}
]
def _os_version(self) -> str:
version = super()._os_version()
return f"FreeBSD {version}" if version else ""
def _hardware(self) -> tuple[str, str, str]:
smbios = self._platform()
return smbios.get("maker", ""), smbios.get("product", ""), smbios.get("serial", "")