Files
napalm-openmediavault/tests/test_local_accounts.py
T
Christian Manivong 61ee8c8db8
driver / standard (pull_request) Successful in 15s
driver / lint (pull_request) Successful in 15s
driver / types (pull_request) Successful in 1m26s
driver / test (3.12) (pull_request) Successful in 1m20s
driver / test (3.13) (pull_request) Successful in 1m12s
driver / lowest (pull_request) Successful in 29s
driver / build (pull_request) Successful in 28s
driver / security (pull_request) Successful in 1m11s
CI / driver (pull_request) Successful in 3m1s
driver / publish (pull_request) Skipped
fix: no fixed uid for netOrk's own account on OMV yet (NetOrk/netork#1817)
Its keys go through UserMgmt, which knows only the users it made, and whether
setUser takes a uid is untested: _account_create_with_uid raises
NotImplementedError, so the switch fails and says why.
2026-11-01 12:42:31 +01:00

256 lines
9.7 KiB
Python

"""Personal accounts on OpenMediaVault, the way its web UI makes them (NetOrk/netork#1793).
napalm-linux adds and locks accounts with shadow-utils and keys in ``~/.ssh``.
On OMV that is not enough: sshd lets in only ``root`` and the ``_ssh`` group,
and a user's keys live in OMV's database, which the ``ssh`` module deploys to
``/var/lib/openmediavault/ssh/authorized_keys/<user>``. So the account is made
through ``UserMgmt.setUser``, the keys go through it as well, and only the
modules that change made dirty are applied.
"""
from __future__ import annotations
import json
import shlex
import pytest
from napalm_device_types import CommandResult
from napalm_openmediavault._local_accounts import OMV_KEYS_DIR, rfc4716_blob
from napalm_openmediavault.openmediavault import OpenMediaVaultDriver
ALICE_KEY = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAlice alice@laptop"
OWN_KEY = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQOwn own@desktop"
HASH = "$6$salt$" + "x" * 86
def _rfc4716(key: str) -> str:
"""*key* as OMV stores it."""
kind, blob, comment = key.split(" ", 2)
lines = [blob[i : i + 70] for i in range(0, len(blob), 70)]
return "\n".join(
[
"---- BEGIN SSH2 PUBLIC KEY ----",
f'Comment: "{comment}"',
*lines,
"---- END SSH2 PUBLIC KEY ----",
]
)
class Omv:
"""omv-rpc and the dirty-modules file, as ``_sudo_status`` sees them."""
def __init__(self, *, dirty=("apt",), deploys=True):
self.users: dict[str, dict] = {
"alice": {
"name": "alice",
"groups": ["users", "_ssh"],
"email": "alice@example.net",
"disallowusermod": False,
"comment": "Alice",
"shell": "/bin/bash",
"sshpubkeys": [_rfc4716(OWN_KEY)],
}
}
#: What the ssh module last wrote, per user: OpenSSH lines.
self.deployed: dict[str, list[str]] = {"alice": [OWN_KEY]}
self.dirty = list(dirty)
self.deploys = deploys
self.calls: list[tuple[str, object]] = []
def __call__(self, command: str, read_timeout: float = 100) -> tuple[str, int | None]:
if command.startswith("cat /var/lib/openmediavault/dirtymodules.json"):
return json.dumps(self.dirty), 0
argv = shlex.split(command)
assert argv[:3] == ["omv-rpc", "-u", "admin"], command
method = f"{argv[3]}.{argv[4]}"
params = json.loads(argv[5]) if len(argv) > 5 else None
self.calls.append((method, params))
if method == "UserMgmt.getUser":
return json.dumps(self.users[params["name"]]), 0
if method == "UserMgmt.setUser":
assert params["password"] == "", "OMV takes the plain password: none is sent"
self.users[params["name"]] = {
**params,
"sshpubkeys": [
k if k.startswith("----") else _rfc4716(k) for k in params["sshpubkeys"]
],
}
# As OMV 8 does: the user's mail alias and keys are to be deployed.
self.dirty += [m for m in ("postfix", "ssh") if m not in self.dirty]
return json.dumps(params), 0
if method == "Config.applyChanges":
if "ssh" in params["modules"] and self.deploys:
for name, user in self.users.items():
self.deployed[name] = [_openssh(k) for k in user["sshpubkeys"]]
self.dirty = [m for m in self.dirty if m not in params["modules"]]
return "null", 0
raise AssertionError(command)
def params(self, method: str) -> list:
return [p for m, p in self.calls if m == method]
def _openssh(rfc: str) -> str:
blob = rfc4716_blob(rfc)
kind = "ssh-ed25519" if "ZDI1NTE5" in (blob or "") else "ssh-rsa"
return f"{kind} {blob}"
class _Driver(OpenMediaVaultDriver):
"""OMV's own calls go to *omv*; the key files sshd reads come from it too."""
def __init__(self, omv: Omv, home_keys: list[str] | None = None) -> None:
super().__init__("nas", "netadmin", "p")
self.omv = omv
self.home_keys = home_keys if home_keys is not None else []
self.ran: list[tuple[str, bool]] = []
def _sudo_status(self, command: str, read_timeout: float = 100) -> tuple[str, int | None]:
return self.omv(command, read_timeout)
def run_command(self, command, *, privileged=False, timeout=60, stdin=None):
self.ran.append((command, privileged))
argv = shlex.split(command)
if argv[:2] == ["test", "-e"]:
path = argv[2]
there = path.startswith(OMV_KEYS_DIR) and path.rsplit("/", 1)[1] in self.omv.deployed
there = there or (path.endswith("/.ssh/authorized_keys") and bool(self.home_keys))
return CommandResult("", "", 0 if there else 1)
if argv[:3] == ["sudo", "-n", "-u"] and argv[4] == "cat":
path = argv[-1]
if path.startswith(OMV_KEYS_DIR):
lines = self.omv.deployed[path.rsplit("/", 1)[1]]
else:
lines = self.home_keys
return CommandResult("".join(f"{line}\n" for line in lines), "", 0)
if argv[:3] == ["sudo", "-n", "-u"] and argv[4] == "rm":
self.home_keys = []
return CommandResult("", "", 0)
raise AssertionError(command)
def test_omv_offers_personal_accounts_of_its_own() -> None:
assert callable(getattr(OpenMediaVaultDriver, "add_local_account", None))
assert callable(getattr(OpenMediaVaultDriver, "lock_local_account", None))
assert callable(getattr(OpenMediaVaultDriver, "get_local_accounts", None))
def test_the_key_file_omv_deploys_is_read_too() -> None:
files = _Driver(Omv())._account_key_files("alice", "/home/alice")
assert files[-1] == f"{OMV_KEYS_DIR}/alice"
assert "/home/alice/.ssh/authorized_keys" in files
def test_a_new_account_is_made_by_omv_in_its_ssh_group() -> None:
omv = Omv()
commands = _Driver(omv)._account_create("bob", HASH)
[params] = omv.params("UserMgmt.setUser")
assert params["name"] == "bob" and params["groups"] == ["_ssh"]
# OMV hashes a plain password itself; netOrk has the hash only.
assert params["password"] == "" and params["sshpubkeys"] == []
assert commands == [["usermod", "-p", HASH, "bob"]]
def test_making_an_account_applies_what_it_made_dirty_and_nothing_else() -> None:
omv = Omv()
_Driver(omv)._account_create("bob", None)
assert omv.params("Config.applyChanges") == [{"modules": ["postfix", "ssh"], "force": False}]
assert omv.dirty == ["apt"]
def test_without_a_hash_no_password_is_set() -> None:
assert _Driver(Omv())._account_create("bob", None) == []
def test_opening_again_puts_the_account_back_into_ssh() -> None:
commands = _Driver(Omv())._account_open("alice", HASH, locked=True)
assert commands[-1] == ["gpasswd", "-a", "alice", "_ssh"]
assert ["usermod", "-e", "", "-p", HASH, "alice"] in commands
def test_a_key_goes_into_omvs_database_and_is_deployed() -> None:
omv = Omv()
outcome = _Driver(omv)._account_add_key("alice", "/home/alice", ALICE_KEY)
assert outcome["ok"], outcome["output"]
[params] = omv.params("UserMgmt.setUser")
assert params["sshpubkeys"] == [_rfc4716(OWN_KEY), ALICE_KEY]
# Everything else the user had stays as it was.
assert params["email"] == "alice@example.net" and params["groups"] == ["users", "_ssh"]
assert params["comment"] == "Alice" and params["shell"] == "/bin/bash"
# Only what the change made dirty is applied: the pending apt change stays.
assert omv.params("Config.applyChanges") == [{"modules": ["postfix", "ssh"], "force": False}]
assert omv.dirty == ["apt"]
assert any("AAAAC3NzaC1lZDI1NTE5AAAAIAlice" in k for k in omv.deployed["alice"])
def test_a_key_already_there_is_not_added_again() -> None:
omv = Omv()
outcome = _Driver(omv)._account_add_key("alice", "/home/alice", OWN_KEY)
assert outcome["ok"] and "already" in outcome["output"]
assert omv.params("UserMgmt.setUser") == []
def test_a_key_omv_does_not_deploy_fails_the_step() -> None:
outcome = _Driver(Omv(deploys=False))._account_add_key("alice", "/home/alice", ALICE_KEY)
assert not outcome["ok"]
assert "not deployed" in outcome["output"]
def test_locking_empties_omvs_keys_and_the_home_ones() -> None:
omv = Omv()
driver = _Driver(omv, home_keys=[ALICE_KEY])
outcome = driver._account_remove_keys("alice", "/home/alice")
assert outcome["ok"], outcome["output"]
[params] = omv.params("UserMgmt.setUser")
assert params["sshpubkeys"] == []
assert omv.deployed["alice"] == [] and driver.home_keys == []
def test_an_account_omv_holds_no_key_for_is_not_written() -> None:
omv = Omv()
omv.users["alice"]["sshpubkeys"] = []
omv.deployed["alice"] = []
outcome = _Driver(omv, home_keys=[ALICE_KEY])._account_remove_keys("alice", "/home/alice")
assert outcome["ok"], outcome["output"]
assert omv.params("UserMgmt.setUser") == []
@pytest.mark.parametrize(
("text", "blob"),
[
(_rfc4716(ALICE_KEY), "AAAAC3NzaC1lZDI1NTE5AAAAIAlice"),
(
'---- BEGIN SSH2 PUBLIC KEY ----\nComment: "a long \\\ncomment"\nAAAA\nBBBB\n'
"---- END SSH2 PUBLIC KEY ----",
"AAAABBBB",
),
(ALICE_KEY, "AAAAC3NzaC1lZDI1NTE5AAAAIAlice"),
("nonsense", None),
],
)
def test_the_key_omv_stores_is_read_back_as_its_base64(text: str, blob: str | None) -> None:
assert rfc4716_blob(text) == blob
def test_netorks_own_account_with_a_fixed_uid_is_not_made_on_omv_yet() -> None:
"""Its keys go through UserMgmt, which knows only the users it made (NetOrk/netork#1817)."""
import pytest
with pytest.raises(NotImplementedError):
_Driver(Omv())._account_create_with_uid("netork", 900)