Merge pull request 'feat: LocalAccountsMixin, personal accounts added and locked again (NetOrk/netork#1793)' (#62) from feat/local-accounts into main
driver / standard (push) Failing after 16s
driver / lint (push) Successful in 14s
driver / test (3.12) (push) Successful in 1m4s
driver / types (push) Successful in 1m6s
driver / lowest (push) Failing after 5s
driver / test (3.13) (push) Successful in 1m2s
driver / build (push) Successful in 31s
driver / security (push) Successful in 1m11s
CI / driver (push) Failing after 2m47s
driver / publish (push) Skipped

Reviewed-on: #62
This commit was merged in pull request #62.
This commit is contained in:
christianmanivong committed 2026-10-31 23:45:34 +00:00
commit 1c71fe6896
4 files changed
+1300

No files matched your search

+11
View File
@@ -14,6 +14,17 @@ recorded here; their history is the git log.
3.12 venv no longer has.
### Added
- `LocalAccountsMixin` (`napalm_device_types.local_accounts`): personal login accounts
on a host. `get_local_accounts(names)` reads them back (groups, lock, sudo, key
files), `add_local_account(name, public_key, password_hash=, admin=)` creates or
reopens one, `lock_local_account(name)` takes its keys and sudo away and refuses
every login while keeping its home. Every command root runs is one fixed command,
the key files are read and written as the account itself, and the sudo rule is a
drop-in of its own, checked with `visudo` and `sudo -l`. A driver supplies the
commands that create, open and lock an account and take it out of a group, and may
replace where the keys are kept (`_account_key_files`, `_account_read_keys`,
`_account_add_key`, `_account_remove_keys`; default `~/.ssh/authorized_keys`)
(NetOrk/netork#1793).
- `OpenSshServerMixin.exempt_from_ssh_penalties`: puts the address the host sees
the managing client at (`$SSH_CONNECTION`) into `PerSourcePenaltyExemptList`,
in `/etc/ssh/sshd_config.d/00-netork-penalty-exempt.conf`, next to the host's
+9
View File
@@ -48,6 +48,7 @@ instead of being restated on every role that happens to need it:
* :class:`~napalm_device_types.interface_filter.InterfaceFilterMixin`
* :class:`~napalm_device_types.kernel.KernelFactsMixin`
* :class:`~napalm_device_types.listening.ListeningSocketsMixin`
* :class:`~napalm_device_types.local_accounts.LocalAccountsMixin`
* :class:`~napalm_device_types.host_firewall.HostFirewallMixin`
* :class:`~napalm_device_types.mac_acl.MacAclMixin`
* :class:`~napalm_device_types.nat_vpn.NatVpnMixin`
@@ -123,6 +124,11 @@ from napalm_device_types.listening import (
ListeningSocketsUnavailable,
parse_listening_sockets,
)
from napalm_device_types.local_accounts import (
LocalAccountChangeDict,
LocalAccountDict,
LocalAccountsMixin,
)
from napalm_device_types.mac_acl import MacAclMixin
from napalm_device_types.management_controller import ManagementControllerDriver
from napalm_device_types.media import MediaDriver
@@ -317,6 +323,9 @@ __all__ = [
"ListeningSocketsMixin",
"ListeningSocketsUnavailable",
"parse_listening_sockets",
"LocalAccountsMixin",
"LocalAccountDict",
"LocalAccountChangeDict",
"PhoneDriver",
"PingSweepMixin",
"PortSpec",
+588
View File
@@ -0,0 +1,588 @@
"""Personal login accounts on a host: reading them, adding one, locking one again.
A person who is to work on a host gets an account of their own: they log in
with their public key and, where they are to administer the host, may use
sudo with their own password. When they leave, the account is locked, not
deleted: their key goes, sudo goes, the login is refused, and the home stays.
:class:`LocalAccountsMixin` holds what is the same on every POSIX host -- the
checks, reading an account back, the order of the steps, the key file and the
sudo rule. A driver supplies the commands that differ between operating
systems: creating, opening and locking an account, reading its lock, and
taking it out of a group.
**Every command root runs is one fixed command**, with no shell syntax of its
own -- ``useradd ...``, ``install -m 440 ...``, ``rm -f -- <path>`` -- so a
sudoers allowlist of commands can name each one. What goes into a file is
staged first, without privilege; root never reads stdin, where a sudo that
does not prompt would leave the password.
**Nothing root runs follows the person's files.** The key files live in a home
the person owns, where a symbolic link may point anywhere, so they are read and
written as that person (``sudo -n -u <name>``). Only the existence of a key
file is asked as root.
**The sudo rule is a file of its own** in the drop-in directory sudo includes,
``<name> ALL=(ALL) ALL``: the person's own password, as on a new VM. A group
alone is not enough, as some distributions grant ``%wheel`` and others
``%sudo``. ``visudo`` checks the rule before it is installed, and ``sudo -l``
afterwards shows whether it took effect. A rule elsewhere -- cloud-init's
``90-cloud-init-users`` -- is not edited; it is reported.
**The login user's own account and system accounts are never touched**:
locking the first would lock the caller out.
"""
from __future__ import annotations
import re
import shlex
from collections.abc import Iterable, Sequence
from typing import TYPE_CHECKING, ClassVar
from typing_extensions import TypedDict
from napalm_device_types.fixes import run_fix_steps
from napalm_device_types.models import FixResultDict, FixStepDict, FixStepOutcomeDict
if TYPE_CHECKING: # pragma: no cover - for type checkers only
from napalm_device_types.channel import CommandResult
#: A login name every POSIX host takes as it is: lowercase, a letter or an
#: underscore first, at most 32 characters. It is also safe in a root command.
ACCOUNT_NAME_RE = re.compile(r"[a-z_][a-z0-9_.-]{0,31}")
#: The crypt(3) prefixes of each password scheme a driver may take.
PASSWORD_SCHEMES: dict[str, tuple[str, ...]] = {
"sha512": ("$6$",),
"bcrypt": ("$2b$", "$2a$", "$2y$"),
}
_CRYPT_RE = re.compile(r"\$[0-9a-z]+\$[./0-9A-Za-z$]+")
#: The public key types OpenSSH takes in a key file.
_KEY_TYPE_RE = re.compile(
r"(ssh-ed25519|ssh-rsa|ecdsa-sha2-nistp(256|384|521)"
r"|sk-ssh-ed25519@openssh\.com|sk-ecdsa-sha2-nistp256@openssh\.com)"
)
_KEY_BLOB_RE = re.compile(r"[A-Za-z0-9+/]+={0,3}")
#: Before the rule's file name; after cloud-init's ``90-`` it would win, so before it.
SUDOERS_FILE_PREFIX = "80-account-"
#: A line of ``sudo -l`` that lets the account run every command as root.
_RUN_ALL_RE = re.compile(r"^\s*\(ALL(\s*:\s*ALL)?\)\s+([A-Z_]+:\s*)*ALL\s*$", re.MULTILINE)
#: Stages stdin as a file anyone may read -- the person reads the key file
#: from it -- and prints its path. The content is a public key or a sudo rule.
_STAGE = 't=$(mktemp) && chmod 644 "$t" && cat > "$t" && printf %s "$t"'
class LocalAccountDict(TypedDict):
"""A person's account as the host has it (``get_local_accounts``)."""
name: str
uid: int
home: str
shell: str
#: Primary group first.
groups: list[str]
#: No login, with a key or a password.
locked: bool
#: ``sudo -l`` lets it run every command as root.
admin: bool
#: The lines of its key files; None when they could not be read (a locked
#: account cannot run a command any more).
authorized_keys: list[str] | None
class LocalAccountChangeDict(FixResultDict):
"""The result of ``add_local_account`` and ``lock_local_account``."""
#: The account read back after the change; None when it is not there or
#: could not be read.
account: LocalAccountDict | None
def sudoers_rule(name: str) -> str:
"""The rule that lets *name* run everything as root, with its own password."""
return f"{name} ALL=(ALL) ALL\n"
def sudoers_rule_path(directory: str, name: str) -> str:
"""Where *name*'s rule lives in *directory*.
sudo skips a file whose name holds a dot, so a dot becomes ``_2e``, and an
underscore ``__``: no two names share a file.
"""
escaped = name.replace("_", "__").replace(".", "_2e")
return f"{directory}/{SUDOERS_FILE_PREFIX}{escaped}"
def authorized_keys_paths(home: str) -> tuple[str, str]:
"""The key files sshd reads in *home* unless configured otherwise."""
return f"{home}/.ssh/authorized_keys", f"{home}/.ssh/authorized_keys2"
def check_account_name(name: str) -> None:
""":raises ValueError: when *name* is no login name every host takes."""
if not ACCOUNT_NAME_RE.fullmatch(name):
raise ValueError(f"not an account name: {name!r}")
def _key_blob(line: str) -> str | None:
"""The base64 part of a key file line, options and comment aside."""
words = line.split()
for i, word in enumerate(words[:-1]):
if _KEY_TYPE_RE.fullmatch(word):
return words[i + 1]
return None
def check_public_key(key: str) -> None:
""":raises ValueError: when *key* is not one OpenSSH public key on one line."""
words = key.split()
if (
"\n" in key.strip()
or len(words) < 2
or not _KEY_TYPE_RE.fullmatch(words[0])
or not _KEY_BLOB_RE.fullmatch(words[1])
):
raise ValueError("not a public key: expected '<type> <base64> [comment]' on one line")
def _command(argv: Sequence[str]) -> str:
return shlex.join(argv)
def _as(name: str, *argv: str) -> str:
"""*argv* run as *name*, from root: nothing it does reaches beyond that account."""
return _command(["sudo", "-n", "-u", name, *argv])
def _said(result: CommandResult) -> str:
return (result.stderr or result.stdout).strip() or f"exit {result.exit_code}"
class LocalAccountsMixin:
"""Reads, adds and locks personal accounts; a driver supplies the OS's commands.
Mixed in by the drivers that can, so ``callable(getattr(driver,
"add_local_account", None))`` says whether a driver can.
"""
#: The login shell of a new account.
ACCOUNT_SHELL: ClassVar[str] = "/bin/sh"
#: The password scheme the host's accounts take, a key of :data:`PASSWORD_SCHEMES`.
ACCOUNT_PASSWORD_SCHEME: ClassVar[str] = "sha512"
#: Groups that make an account an administrator; a person without sudo leaves them.
ACCOUNT_ADMIN_GROUPS: ClassVar[tuple[str, ...]] = ("wheel",)
#: The lowest uid of a person's account; below are the system's.
ACCOUNT_MIN_UID: ClassVar[int] = 1000
#: The drop-in directory sudo includes.
SUDOERS_DIR: ClassVar[str] = "/etc/sudoers.d"
#: The group of root's files.
ROOT_GROUP: ClassVar[str] = "root"
if TYPE_CHECKING: # pragma: no cover - declared for type checkers only
def run_command(
self,
command: str,
*,
privileged: bool = False,
timeout: float = 60,
stdin: bytes | None = None,
) -> CommandResult: ...
# -- what a driver supplies ------------------------------------------------------
#
# ``_account_*`` are the driver's: the five below it must supply, the key
# store (``_account_key_files``, ``_account_read_keys``, ``_account_add_key``,
# ``_account_remove_keys``) it may replace. ``_accounts_*`` are this mixin's own.
def _account_create(self, name: str, password_hash: str | None) -> list[list[str]]:
"""The commands that create *name* with a home and :attr:`ACCOUNT_SHELL`.
Without *password_hash* the account takes no password, only a key.
"""
raise NotImplementedError
def _account_open(
self, name: str, password_hash: str | None, *, locked: bool
) -> list[list[str]]:
"""The commands that let *name* log in again, with *password_hash* if given."""
raise NotImplementedError
def _account_lock(self, name: str, *, locked: bool) -> list[list[str]]:
"""The commands that refuse *name* every login, a key's too; none when *locked*."""
raise NotImplementedError
def _account_locked(self, name: str, passwd: list[str]) -> bool:
"""Whether *name* is locked; *passwd* is its ``getent passwd`` line, split.
:raises RuntimeError: when that cannot be read.
"""
raise NotImplementedError
def _account_leave_group(self, name: str, group: str, groups: list[str]) -> list[str]:
"""The command that takes *name* out of *group*; *groups* are all of its own."""
raise NotImplementedError
# -- reading ---------------------------------------------------------------------
def get_local_accounts(self, names: Iterable[str]) -> list[LocalAccountDict]:
"""The accounts of *names* the host has, in that order; a missing one is left out.
:raises ValueError: for a name that is no account name.
:raises RuntimeError: when an account cannot be read.
"""
wanted = list(names)
for name in wanted:
check_account_name(name)
found = (self._accounts_read(name) for name in wanted)
return [account for account in found if account is not None]
def _accounts_passwd(self, name: str) -> list[str] | None:
result = self.run_command(_command(["getent", "passwd", name]), timeout=30)
if result.exit_code == 2:
return None
fields = result.stdout.strip().split(":")
if result.exit_code != 0 or len(fields) < 7 or fields[0] != name:
raise RuntimeError(f"cannot read the account {name}: {_said(result)}")
return fields
def _accounts_read(self, name: str) -> LocalAccountDict | None:
passwd = self._accounts_passwd(name)
if passwd is None:
return None
groups = self.run_command(_command(["id", "-Gn", name]), timeout=30)
if groups.exit_code != 0:
raise RuntimeError(f"cannot read the groups of {name}: {_said(groups)}")
home = passwd[5]
return {
"name": name,
"uid": int(passwd[2]),
"home": home,
"shell": passwd[6],
"groups": groups.stdout.split(),
"locked": self._account_locked(name, passwd),
"admin": self._accounts_admin(name),
"authorized_keys": self._account_read_keys(name, home),
}
def _accounts_admin(self, name: str) -> bool:
result = self.run_command(_command(["sudo", "-l", "-U", name]), privileged=True, timeout=30)
if result.exit_code != 0:
raise RuntimeError(f"cannot ask sudo about {name}: {_said(result)}")
return bool(_RUN_ALL_RE.search(result.stdout))
def _account_key_files(self, name: str, home: str) -> tuple[str, ...]:
"""Every file sshd reads *name*'s keys from; a host that adds one of its own says so."""
return authorized_keys_paths(home)
def _account_read_keys(self, name: str, home: str) -> list[str] | None:
"""The lines of :meth:`_account_key_files`, read as *name*; None when it cannot."""
lines: list[str] = []
for path in self._account_key_files(name, home):
there = self.run_command(_command(["test", "-e", path]), privileged=True, timeout=30)
if there.exit_code != 0:
continue
result = self.run_command(_as(name, "cat", "--", path), privileged=True, timeout=30)
if result.exit_code != 0:
return None
lines += [ln for ln in result.stdout.splitlines() if ln.strip()]
return lines
# -- changing ----------------------------------------------------------------------
def add_local_account(
self,
name: str,
public_key: str,
*,
password_hash: str | None = None,
admin: bool = False,
) -> LocalAccountChangeDict:
"""Give *name* an account that logs in with *public_key*, or open it again.
An account that is there is opened again and keeps its other keys; a
new one gets a home. *password_hash* (crypt(3), in
:attr:`ACCOUNT_PASSWORD_SCHEME`) becomes its password; *admin* gives it
the sudo rule, which asks for that password -- so an administrator
needs one. Without *admin*, the rule and :attr:`ACCOUNT_ADMIN_GROUPS`
are taken away.
Steps: ``account``, then ``sudo`` and ``keys``, each of which runs when
the other failed.
:raises ValueError: for a name, key or hash no host takes, the login
user's own account, or a system account.
"""
check_account_name(name)
check_public_key(public_key)
if password_hash is not None:
self._accounts_check_hash(password_hash)
existing = self._accounts_changeable(name)
first = run_fix_steps(
[("account", lambda: self._accounts_open_or_create(name, existing, password_hash))]
)
parts = [first]
if first["success"]:
parts += [
run_fix_steps([("sudo", lambda: self._accounts_set_sudo(name, admin=admin))]),
run_fix_steps([("keys", lambda: self._accounts_add_key(name, public_key))]),
]
return self._accounts_result(name, parts)
def lock_local_account(self, name: str) -> LocalAccountChangeDict:
"""Lock *name*: its keys go, every login is refused, sudo goes; its home stays.
Steps ``keys``, ``lock`` and ``sudo``, each run when one before failed:
the lock matters most. A sudo rule outside the drop-in directory is
reported, not edited -- with the account locked it can no longer be used.
:raises ValueError: for a name no host takes, the login user's own
account, or a system account.
"""
check_account_name(name)
if self._accounts_changeable(name) is None:
step: FixStepDict = {"step": "account", "ok": False, "output": f"no account {name}"}
return {**_joined([step]), "account": None}
parts = [
run_fix_steps([("keys", lambda: self._accounts_remove_keys(name))]),
run_fix_steps([("lock", lambda: self._accounts_lock(name))]),
run_fix_steps(
[("sudo", lambda: self._accounts_set_sudo(name, admin=False, locked=True))]
),
]
return self._accounts_result(name, parts)
def _accounts_check_hash(self, password_hash: str) -> None:
prefixes = PASSWORD_SCHEMES[self.ACCOUNT_PASSWORD_SCHEME]
if not _CRYPT_RE.fullmatch(password_hash) or not password_hash.startswith(prefixes):
raise ValueError(f"not a {self.ACCOUNT_PASSWORD_SCHEME} password hash")
def _accounts_changeable(self, name: str) -> list[str] | None:
"""*name*'s passwd line, None when there is none.
:raises ValueError: for the login user's own account or a system account.
:raises RuntimeError: when the login user cannot be told.
"""
login = self.run_command("id -un", timeout=30).stdout.strip()
if not login:
raise RuntimeError("cannot tell which account this driver logs in with")
if name == login:
raise ValueError(f"{name} is the account this driver logs in with")
passwd = self._accounts_passwd(name)
if passwd is not None and int(passwd[2]) < self.ACCOUNT_MIN_UID:
raise ValueError(f"{name} is a system account (uid {passwd[2]})")
return passwd
def _accounts_result(self, name: str, parts: list[FixResultDict]) -> LocalAccountChangeDict:
steps = [s for part in parts for s in part["steps"]]
result = _joined(steps)
account: LocalAccountDict | None = None
try:
account = self._accounts_read(name)
except RuntimeError as exc:
result["output"] += f"\n[read back] {exc}"
return {**result, "account": account}
def _accounts_root(self, argv: Sequence[str]) -> CommandResult:
return self.run_command(_command(argv), privileged=True, timeout=60)
def _accounts_run(self, commands: list[list[str]]) -> CommandResult | None:
"""Run *commands* as root in order; the first that failed, or None."""
for argv in commands:
result = self._accounts_root(argv)
if result.exit_code != 0:
return result
return None
def _accounts_open_or_create(
self, name: str, passwd: list[str] | None, password_hash: str | None
) -> FixStepOutcomeDict:
if passwd is None:
failed = self._accounts_run(self._account_create(name, password_hash))
done = f"account {name} created"
else:
locked = self._account_locked(name, passwd)
failed = self._accounts_run(self._account_open(name, password_hash, locked=locked))
done = f"account {name} opened again" if locked else f"account {name} is there"
if failed is not None:
return {"ok": False, "output": _said(failed)}
return {"ok": True, "output": done + (", password set" if password_hash else "")}
def _accounts_lock(self, name: str) -> FixStepOutcomeDict:
passwd = self._accounts_passwd(name)
if passwd is None:
return {"ok": False, "output": f"no account {name}"}
locked = self._account_locked(name, passwd)
failed = self._accounts_run(self._account_lock(name, locked=locked))
if failed is not None:
return {"ok": False, "output": _said(failed)}
if not self._account_locked(name, passwd):
return {"ok": False, "output": f"{name} is still not locked"}
return {"ok": True, "output": f"{name} was locked already" if locked else f"{name} locked"}
# -- sudo --------------------------------------------------------------------------
def _accounts_set_sudo(
self, name: str, *, admin: bool, locked: bool = False
) -> FixStepOutcomeDict:
path = sudoers_rule_path(self.SUDOERS_DIR, name)
if admin:
return self._accounts_grant_sudo(name, path)
said: list[str] = []
removed = self._accounts_root(["rm", "-f", "--", path])
if removed.exit_code != 0:
return {"ok": False, "output": f"{path}: {_said(removed)}"}
groups = self.run_command(_command(["id", "-Gn", name]), timeout=30).stdout.split()
for group in self.ACCOUNT_ADMIN_GROUPS:
if group not in groups[1:]:
continue
left = self._accounts_root(self._account_leave_group(name, group, groups))
if left.exit_code != 0:
return {"ok": False, "output": f"cannot take {name} out of {group}: {_said(left)}"}
groups.remove(group)
said.append(f"{name} left {group}")
if self._accounts_admin(name):
rest = f"another rule than {path} still lets {name} run everything as root"
if locked:
return {"ok": True, "output": f"{rest}; the account is locked, so it cannot use it"}
return {"ok": False, "output": rest}
said.append(f"{name} has no sudo")
return {"ok": True, "output": "\n".join(said)}
def _accounts_grant_sudo(self, name: str, path: str) -> FixStepOutcomeDict:
staged = self._accounts_stage(sudoers_rule(name))
try:
checked = self._accounts_root(["visudo", "-cf", staged])
if checked.exit_code != 0:
return {"ok": False, "output": f"visudo refuses the rule: {_said(checked)}"}
installed = self._accounts_root(
["install", "-m", "440", "-o", "root", "-g", self.ROOT_GROUP, "--", staged, path]
)
if installed.exit_code != 0:
return {"ok": False, "output": f"{path}: {_said(installed)}"}
finally:
self._accounts_unstage(staged)
if not self._accounts_admin(name):
return {
"ok": False,
"output": f"{path} is written, but sudo does not read it: "
f"does sudoers include {self.SUDOERS_DIR}?",
}
return {"ok": True, "output": f"{name} may use sudo with its password ({path})"}
# -- keys --------------------------------------------------------------------------
def _accounts_stage(self, content: str) -> str:
"""*content* in a fresh file of the login user's; its path.
:raises RuntimeError: when it cannot be staged.
"""
result = self.run_command(_STAGE, timeout=30, stdin=content.encode())
path = result.stdout.strip().splitlines()[-1:] or [""]
if result.exit_code != 0 or not path[0].startswith("/"):
raise RuntimeError(f"cannot stage a file: {_said(result)}")
return path[0]
def _accounts_unstage(self, path: str) -> None:
self.run_command(_command(["rm", "-f", "--", path]), timeout=30)
def _accounts_home(self, name: str) -> str | None:
passwd = self._accounts_passwd(name)
return passwd[5] if passwd is not None else None
def _accounts_add_key(self, name: str, public_key: str) -> FixStepOutcomeDict:
home = self._accounts_home(name)
if home is None:
return {"ok": False, "output": f"no account {name}"}
return self._account_add_key(name, home, public_key)
def _accounts_remove_keys(self, name: str) -> FixStepOutcomeDict:
home = self._accounts_home(name)
if home is None:
return {"ok": False, "output": f"no account {name}"}
return self._account_remove_keys(name, home)
def _account_add_key(self, name: str, home: str, public_key: str) -> FixStepOutcomeDict:
"""Add *public_key* to *name*'s first key file, as *name*; the others stay.
A driver whose host keeps keys elsewhere overrides this, with
:meth:`_account_read_keys` and :meth:`_account_remove_keys`.
"""
path = authorized_keys_paths(home)[0]
current = self._account_read_keys(name, home)
if current is None:
return {"ok": False, "output": f"cannot read the key files of {name}"}
blob = _key_blob(public_key)
if any(_key_blob(line) == blob for line in current):
return {"ok": True, "output": f"the key is already in {path}"}
mine = self._accounts_key_file(name, path)
if mine is None:
return {"ok": False, "output": f"cannot read {path}"}
staged = self._accounts_stage("".join(f"{line}\n" for line in [*mine, public_key.strip()]))
try:
failed = self._accounts_run_as(
name,
[
["mkdir", "-p", "-m", "700", "--", f"{home}/.ssh"],
["install", "-m", "600", "--", staged, path],
],
)
finally:
self._accounts_unstage(staged)
if failed is not None:
return {"ok": False, "output": f"{path}: {_said(failed)}"}
return {"ok": True, "output": f"key added to {path}"}
def _accounts_key_file(self, name: str, path: str) -> list[str] | None:
there = self.run_command(_command(["test", "-e", path]), privileged=True, timeout=30)
if there.exit_code != 0:
return []
result = self.run_command(_as(name, "cat", "--", path), privileged=True, timeout=30)
if result.exit_code != 0:
return None
return [line for line in result.stdout.splitlines() if line.strip()]
def _accounts_run_as(self, name: str, commands: list[list[str]]) -> CommandResult | None:
for argv in commands:
result = self.run_command(_as(name, *argv), privileged=True, timeout=60)
if result.exit_code != 0:
return result
return None
def _account_remove_keys(self, name: str, home: str) -> FixStepOutcomeDict:
"""Remove *name*'s key files in *home*, as *name*; then no key may be left."""
paths = authorized_keys_paths(home)
failed = self._accounts_run_as(name, [["rm", "-f", "--", *paths]])
if failed is not None:
return {"ok": False, "output": f"cannot remove the keys of {name}: {_said(failed)}"}
if self._account_read_keys(name, home):
return {"ok": False, "output": f"{name} still has keys"}
return {"ok": True, "output": f"keys of {name} removed"}
def _joined(steps: list[FixStepDict]) -> FixResultDict:
return {
"success": bool(steps) and all(s["ok"] for s in steps),
"steps": steps,
"output": "\n".join(f"[{s['step']}] {s['output']}".rstrip() for s in steps),
}
__all__ = [
"ACCOUNT_NAME_RE",
"PASSWORD_SCHEMES",
"SUDOERS_FILE_PREFIX",
"LocalAccountChangeDict",
"LocalAccountDict",
"LocalAccountsMixin",
"authorized_keys_paths",
"check_account_name",
"check_public_key",
"sudoers_rule",
"sudoers_rule_path",
]
+692
View File
@@ -0,0 +1,692 @@
"""Personal accounts on a host: reading them, adding one, locking one again.
The host is a fake that keeps accounts, groups, sudo rules and key files in
memory and answers the fixed commands the mixin and a driver send. A driver's
own commands (create, open, lock, leave a group) are stand-ins here; the real
ones are tested in the drivers.
"""
from __future__ import annotations
import shlex
from dataclasses import dataclass, field
import pytest
from napalm_device_types.channel import CommandResult
from napalm_device_types.local_accounts import (
LocalAccountsMixin,
authorized_keys_paths,
sudoers_rule,
sudoers_rule_path,
)
from napalm_device_types.models import FixStepOutcomeDict
ALICE_KEY = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAlice alice@laptop"
OWN_KEY = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQOwn own@desktop"
HASH = "$6$salt$" + "x" * 86
#: Shell syntax a command for root must not hold: each is one fixed command.
SHELL_SYNTAX = (";", "&&", "||", "|", ">", "<", "$(", "`")
@dataclass
class _Account:
uid: int
home: str
shell: str = "/bin/sh"
groups: list[str] = field(default_factory=list)
locked: bool = False
password: str | None = None
class _Host:
"""What the fake host holds, and the commands it ran."""
def __init__(self) -> None:
self.login = "netadmin"
self.accounts: dict[str, _Account] = {
"netadmin": _Account(1000, "/home/netadmin", groups=["netadmin", "wheel"]),
"daemon": _Account(1, "/usr/sbin"),
}
#: Path -> content, for the sudoers drop-ins and the key files.
self.files: dict[str, str] = {}
#: Users a rule outside the drop-in directory lets run everything.
self.other_rules: set[str] = set()
#: Whether sudo reads the drop-in directory at all.
self.includes_dropins = True
#: Commands that fail, by their first words ("as <command>" for one run as
#: the person); and commands that succeed without doing anything.
self.failing: set[str] = set()
self.ignored: set[str] = set()
self.ran: list[tuple[str, bool]] = []
self.staged = 0
def is_admin(self, name: str) -> bool:
rule = self.files.get(sudoers_rule_path(_Driver.SUDOERS_DIR, name))
return name in self.other_rules or (self.includes_dropins and rule is not None)
def run(self, command: str, privileged: bool, stdin: bytes | None) -> CommandResult:
self.ran.append((command, privileged))
if stdin is not None:
assert not privileged, "a privileged command takes no stdin"
return self._stage(command, stdin)
words = shlex.split(command)
if " ".join(words[:2]) in self.failing or words[0] in self.failing:
return CommandResult("", f"{words[0]}: failed", 1)
if words[:3] == ["sudo", "-n", "-u"]:
assert privileged, "only root changes to another user"
return self._as_user(words[3], words[4:])
handler = getattr(self, "_" + words[0].replace("-", "_"), None)
assert handler is not None, f"unexpected command: {command}"
return handler(words[1:], privileged)
# -- staging, as the login user ---------------------------------------------
def _stage(self, command: str, stdin: bytes) -> CommandResult:
assert "mktemp" in command
if "mktemp" in self.failing:
return CommandResult("", "mktemp: No space left on device", 1)
self.staged += 1
path = f"/tmp/tmp.{self.staged}"
self.files[path] = stdin.decode()
return CommandResult(path, "", 0)
def _rm(self, args: list[str], privileged: bool) -> CommandResult:
for path in args[args.index("--") + 1 :]:
if path.startswith("/tmp/"):
assert not privileged, "the staged file is the login user's"
self.files.pop(path, None)
return CommandResult("", "", 0)
# -- the account database -------------------------------------------------------
def _getent(self, args: list[str], privileged: bool) -> CommandResult:
assert args[0] == "passwd" and not privileged
a = self.accounts.get(args[1])
if a is None:
return CommandResult("", "", 2)
return CommandResult(f"{args[1]}:*:{a.uid}:{a.uid}::{a.home}:{a.shell}\n", "", 0)
def _id(self, args: list[str], privileged: bool) -> CommandResult:
if args == ["-un"]:
return CommandResult(f"{self.login}\n", "", 0)
assert args[0] == "-Gn" and not privileged
a = self.accounts.get(args[1])
if a is None:
return CommandResult("", f"id: {args[1]}: no such user", 1)
return CommandResult(" ".join(a.groups) + "\n", "", 0)
def _sudo(self, args: list[str], privileged: bool) -> CommandResult:
assert args[:2] == ["-l", "-U"] and privileged
name = args[2]
if self.is_admin(name):
out = f"User {name} may run the following commands on host:\n (ALL) ALL\n"
else:
out = f"User {name} is not allowed to run sudo on host.\n"
return CommandResult(out, "", 0)
def _visudo(self, args: list[str], privileged: bool) -> CommandResult:
assert args[0] == "-cf" and privileged
content = self.files[args[1]]
ok = content.endswith(" ALL=(ALL) ALL\n") and "\n" not in content[:-1]
return CommandResult("parsed OK" if ok else "syntax error", "", 0 if ok else 1)
def _install(self, args: list[str], privileged: bool) -> CommandResult:
assert privileged
source, target = args[args.index("--") + 1 :]
assert target.startswith(_Driver.SUDOERS_DIR + "/"), "root installs only sudo rules"
assert args[:6] == ["-m", "440", "-o", "root", "-g", _Driver.ROOT_GROUP]
self.files[target] = self.files[source]
return CommandResult("", "", 0)
def _test(self, args: list[str], privileged: bool) -> CommandResult:
assert args[0] == "-e"
return CommandResult("", "", 0 if args[1] in self.files else 1)
# -- the person's own files, as that person ------------------------------------
def _as_user(self, name: str, words: list[str]) -> CommandResult:
a = self.accounts[name]
if a.locked:
return CommandResult("", "sudo: account expired", 1)
rest = words[words.index("--") + 1 :] if "--" in words else words[1:]
if f"as {words[0]}" in self.failing:
return CommandResult("", f"{words[0]}: Permission denied", 1)
if f"as {words[0]}" in self.ignored:
return CommandResult("", "", 0)
assert all(p.startswith(a.home + "/") or p.startswith("/tmp/") for p in rest)
if words[0] == "cat":
return CommandResult(self.files.get(rest[0], ""), "", 0)
if words[0] == "mkdir":
return CommandResult("", "", 0)
if words[0] == "install":
assert words[1:3] == ["-m", "600"]
self.files[rest[1]] = self.files[rest[0]]
return CommandResult("", "", 0)
if words[0] == "rm":
for path in rest:
self.files.pop(path, None)
return CommandResult("", "", 0)
raise AssertionError(f"unexpected command as {name}: {words}")
# -- the driver's own commands (stand-ins) -------------------------------------
def _mkuser(self, args: list[str], privileged: bool) -> CommandResult:
assert privileged
name, password = args[0], (args[1] if len(args) > 1 else None)
uid = 1001 + len(self.accounts)
self.accounts[name] = _Account(uid, f"/home/{name}", groups=[name], password=password)
return CommandResult("", "", 0)
def _openuser(self, args: list[str], privileged: bool) -> CommandResult:
assert privileged
a = self.accounts[args[0]]
a.locked = False
if len(args) > 1:
a.password = args[1]
return CommandResult("", "", 0)
def _lockuser(self, args: list[str], privileged: bool) -> CommandResult:
assert privileged
self.accounts[args[0]].locked = "lockuser" not in self.ignored
return CommandResult("", "", 0)
def _islocked(self, args: list[str], privileged: bool) -> CommandResult:
assert privileged
return CommandResult("yes\n" if self.accounts[args[0]].locked else "no\n", "", 0)
def _leavegroup(self, args: list[str], privileged: bool) -> CommandResult:
assert privileged
self.accounts[args[0]].groups.remove(args[1])
return CommandResult("", "", 0)
class _Driver(LocalAccountsMixin):
ACCOUNT_SHELL = "/bin/sh"
ACCOUNT_ADMIN_GROUPS = ("wheel", "sudo")
SUDOERS_DIR = "/etc/sudoers.d"
ROOT_GROUP = "wheel"
def __init__(self, host: _Host) -> None:
self.host = host
def run_command(
self,
command: str,
*,
privileged: bool = False,
timeout: float = 60,
stdin: bytes | None = None,
) -> CommandResult:
return self.host.run(command, privileged, stdin)
def _account_create(self, name: str, password_hash: str | None) -> list[list[str]]:
return [["mkuser", name, *([password_hash] if password_hash else [])]]
def _account_open(
self, name: str, password_hash: str | None, *, locked: bool
) -> list[list[str]]:
return [["openuser", name, *([password_hash] if password_hash else [])]]
def _account_lock(self, name: str, *, locked: bool) -> list[list[str]]:
return [] if locked else [["lockuser", name]]
def _account_locked(self, name: str, passwd: list[str]) -> bool:
result = self.run_command(shlex.join(["islocked", name]), privileged=True)
return result.stdout.strip() == "yes"
def _account_leave_group(self, name: str, group: str, groups: list[str]) -> list[str]:
return ["leavegroup", name, group]
@pytest.fixture
def host() -> _Host:
return _Host()
@pytest.fixture
def driver(host: _Host) -> _Driver:
return _Driver(host)
def _root_commands(host: _Host) -> list[str]:
return [c for c, privileged in host.ran if privileged]
def _add_alice(host: _Host, *, locked: bool = False, keys: str = "") -> None:
host.accounts["alice"] = _Account(
1001, "/home/alice", groups=["alice", "wheel"], locked=locked, password=HASH
)
if keys:
host.files["/home/alice/.ssh/authorized_keys"] = keys
# -- the helpers ---------------------------------------------------------------------
def test_the_sudo_rule_names_the_account_and_asks_for_its_password() -> None:
assert sudoers_rule("alice") == "alice ALL=(ALL) ALL\n"
def test_the_rule_file_has_no_dot_sudo_would_skip() -> None:
# sudo ignores a file in an included directory whose name holds a dot.
path = sudoers_rule_path("/etc/sudoers.d", "a.lice")
assert path.startswith("/etc/sudoers.d/")
assert "." not in path.rsplit("/", 1)[1]
assert sudoers_rule_path("/etc/sudoers.d", "a.lice") != sudoers_rule_path(
"/etc/sudoers.d", "a_lice"
)
def test_both_key_files_sshd_reads_by_default() -> None:
assert authorized_keys_paths("/home/alice") == (
"/home/alice/.ssh/authorized_keys",
"/home/alice/.ssh/authorized_keys2",
)
# -- reading --------------------------------------------------------------------------
def test_an_account_is_read_with_its_groups_lock_sudo_and_keys(
host: _Host, driver: _Driver
) -> None:
_add_alice(host, keys=ALICE_KEY + "\n" + OWN_KEY + "\n")
host.other_rules.add("alice")
[account] = driver.get_local_accounts(["alice"])
assert account == {
"name": "alice",
"uid": 1001,
"home": "/home/alice",
"shell": "/bin/sh",
"groups": ["alice", "wheel"],
"locked": False,
"admin": True,
"authorized_keys": [ALICE_KEY, OWN_KEY],
}
def test_an_account_that_is_not_there_is_left_out(driver: _Driver) -> None:
assert driver.get_local_accounts(["bob"]) == []
def test_a_locked_accounts_keys_that_cannot_be_read_are_unknown(
host: _Host, driver: _Driver
) -> None:
_add_alice(host, locked=True, keys=ALICE_KEY + "\n")
[account] = driver.get_local_accounts(["alice"])
assert account["locked"] is True
assert account["authorized_keys"] is None
def test_an_account_without_a_key_file_has_no_keys(host: _Host, driver: _Driver) -> None:
_add_alice(host)
[account] = driver.get_local_accounts(["alice"])
assert account["authorized_keys"] == []
def test_a_failing_read_raises_rather_than_report_nothing(host: _Host, driver: _Driver) -> None:
_add_alice(host)
host.failing.add("sudo -l")
with pytest.raises(RuntimeError, match="alice"):
driver.get_local_accounts(["alice"])
@pytest.mark.parametrize("name", ["", "Alice", "1alice", "al ice", "a;b", "-alice", "a" * 33])
def test_a_name_no_guest_takes_is_refused(driver: _Driver, name: str) -> None:
with pytest.raises(ValueError, match="account name"):
driver.get_local_accounts([name])
# -- adding ---------------------------------------------------------------------------
def test_a_new_account_gets_the_key_and_the_sudo_rule(host: _Host, driver: _Driver) -> None:
result = driver.add_local_account("alice", ALICE_KEY, password_hash=HASH, admin=True)
assert result["success"], result["output"]
assert [s["step"] for s in result["steps"]] == ["account", "sudo", "keys"]
assert host.accounts["alice"].password == HASH
assert host.files["/home/alice/.ssh/authorized_keys"] == ALICE_KEY + "\n"
assert host.files["/etc/sudoers.d/80-account-alice"] == "alice ALL=(ALL) ALL\n"
account = result["account"]
assert account is not None
assert account["admin"] is True and account["authorized_keys"] == [ALICE_KEY]
def test_every_command_root_runs_is_one_fixed_command(host: _Host, driver: _Driver) -> None:
driver.add_local_account("alice", ALICE_KEY, password_hash=HASH, admin=True)
driver.lock_local_account("alice")
for command in _root_commands(host):
assert not any(s in command for s in SHELL_SYNTAX), command
def test_the_staged_files_are_removed_again(host: _Host, driver: _Driver) -> None:
driver.add_local_account("alice", ALICE_KEY, password_hash=HASH, admin=True)
assert host.staged == 2
assert not [p for p in host.files if p.startswith("/tmp/")]
def test_an_existing_account_keeps_its_own_keys(host: _Host, driver: _Driver) -> None:
_add_alice(host, keys=OWN_KEY + "\n")
result = driver.add_local_account("alice", ALICE_KEY)
assert result["success"], result["output"]
assert host.files["/home/alice/.ssh/authorized_keys"] == f"{OWN_KEY}\n{ALICE_KEY}\n"
def test_a_line_without_a_key_is_kept_and_not_taken_for_one(host: _Host, driver: _Driver) -> None:
_add_alice(host, keys="# the laptop\n")
result = driver.add_local_account("alice", ALICE_KEY)
assert result["success"], result["output"]
assert host.files["/home/alice/.ssh/authorized_keys"] == f"# the laptop\n{ALICE_KEY}\n"
def test_a_key_already_there_is_not_written_again(host: _Host, driver: _Driver) -> None:
# The same key with options in front and another comment is the same key.
_add_alice(host, keys=f'from="10.0.0.0/8" {ALICE_KEY.rsplit(" ", 1)[0]} old\n')
result = driver.add_local_account("alice", ALICE_KEY)
assert result["success"], result["output"]
assert host.staged == 0
assert "already" in result["steps"][-1]["output"]
def test_a_locked_account_is_opened_again(host: _Host, driver: _Driver) -> None:
_add_alice(host, locked=True)
result = driver.add_local_account("alice", ALICE_KEY, password_hash=HASH)
assert result["success"], result["output"]
assert host.accounts["alice"].locked is False
assert result["account"] is not None and result["account"]["locked"] is False
def test_without_sudo_the_rule_and_the_admin_groups_go(host: _Host, driver: _Driver) -> None:
_add_alice(host)
host.files["/etc/sudoers.d/80-account-alice"] = sudoers_rule("alice")
result = driver.add_local_account("alice", ALICE_KEY, admin=False)
assert result["success"], result["output"]
assert "/etc/sudoers.d/80-account-alice" not in host.files
assert host.accounts["alice"].groups == ["alice"]
def test_sudo_another_rule_still_grants_fails_the_step(host: _Host, driver: _Driver) -> None:
_add_alice(host)
host.other_rules.add("alice")
result = driver.add_local_account("alice", ALICE_KEY, admin=False)
assert not result["success"]
sudo = next(s for s in result["steps"] if s["step"] == "sudo")
assert not sudo["ok"] and "another rule" in sudo["output"]
# The key still went in: the steps after the account are independent.
assert host.files["/home/alice/.ssh/authorized_keys"] == ALICE_KEY + "\n"
def test_a_rule_sudo_does_not_read_fails_the_step(host: _Host, driver: _Driver) -> None:
host.includes_dropins = False
result = driver.add_local_account("alice", ALICE_KEY, password_hash=HASH, admin=True)
sudo = next(s for s in result["steps"] if s["step"] == "sudo")
assert not sudo["ok"] and "/etc/sudoers.d" in sudo["output"]
def test_a_rule_visudo_rejects_is_not_installed(host: _Host, driver: _Driver) -> None:
host.failing.add("visudo")
result = driver.add_local_account("alice", ALICE_KEY, password_hash=HASH, admin=True)
assert not result["success"]
assert "/etc/sudoers.d/80-account-alice" not in host.files
assert not [p for p in host.files if p.startswith("/tmp/")]
def test_a_failed_create_stops_before_sudo_and_keys(host: _Host, driver: _Driver) -> None:
host.failing.add("mkuser")
result = driver.add_local_account("alice", ALICE_KEY, admin=True)
assert not result["success"]
assert [s["step"] for s in result["steps"]] == ["account"]
assert result["account"] is None
@pytest.mark.parametrize(
"key",
["", "not a key", ALICE_KEY + "\n" + OWN_KEY, "ssh-ed25519", "ssh-ed25519 AAAA;rm"],
)
def test_a_public_key_that_is_none_is_refused(driver: _Driver, key: str) -> None:
with pytest.raises(ValueError, match="public key"):
driver.add_local_account("alice", key)
@pytest.mark.parametrize("password_hash", ["secret", "$6$salt$ab cd", "$2b$10$" + "x" * 53])
def test_a_password_hash_the_guest_does_not_take_is_refused(
driver: _Driver, password_hash: str
) -> None:
# This driver takes SHA-512 crypt: neither plain text nor bcrypt.
with pytest.raises(ValueError, match="password hash"):
driver.add_local_account("alice", ALICE_KEY, password_hash=password_hash)
def test_the_login_users_own_account_is_never_touched(host: _Host, driver: _Driver) -> None:
for change in (
lambda: driver.add_local_account("netadmin", ALICE_KEY),
lambda: driver.lock_local_account("netadmin"),
):
with pytest.raises(ValueError, match="logs in"):
change()
assert _root_commands(host) == []
def test_nothing_changes_when_the_login_user_cannot_be_told(host: _Host, driver: _Driver) -> None:
_add_alice(host)
host.login = ""
with pytest.raises(RuntimeError, match="logs in"):
driver.lock_local_account("alice")
assert _root_commands(host) == []
def test_a_system_account_is_never_touched(host: _Host, driver: _Driver) -> None:
with pytest.raises(ValueError, match="system account"):
driver.lock_local_account("daemon")
assert _root_commands(host) == []
# -- locking --------------------------------------------------------------------------
def test_locking_takes_keys_sudo_and_login_away(host: _Host, driver: _Driver) -> None:
_add_alice(host, keys=ALICE_KEY + "\n" + OWN_KEY + "\n")
host.files["/home/alice/.ssh/authorized_keys2"] = OWN_KEY + "\n"
host.files["/etc/sudoers.d/80-account-alice"] = sudoers_rule("alice")
result = driver.lock_local_account("alice")
assert result["success"], result["output"]
assert [s["step"] for s in result["steps"]] == ["keys", "lock", "sudo"]
a = host.accounts["alice"]
assert a.locked and a.groups == ["alice"] and a.password == HASH
assert not [p for p in host.files if p.startswith("/home/alice/")]
assert "/etc/sudoers.d/80-account-alice" not in host.files
account = result["account"]
assert account is not None and account["locked"] and not account["admin"]
def test_a_rule_left_elsewhere_is_named_but_harmless_once_locked(
host: _Host, driver: _Driver
) -> None:
_add_alice(host)
host.other_rules.add("alice")
result = driver.lock_local_account("alice")
assert result["success"], result["output"]
sudo = next(s for s in result["steps"] if s["step"] == "sudo")
assert "another rule" in sudo["output"] and "locked" in sudo["output"]
def test_the_lock_comes_even_when_the_keys_could_not_go(host: _Host, driver: _Driver) -> None:
_add_alice(host, locked=True, keys=ALICE_KEY + "\n")
result = driver.lock_local_account("alice")
assert not result["success"]
keys = next(s for s in result["steps"] if s["step"] == "keys")
assert not keys["ok"]
assert next(s for s in result["steps"] if s["step"] == "lock")["ok"]
assert host.accounts["alice"].locked
def test_locking_an_account_that_is_not_there_fails(driver: _Driver) -> None:
result = driver.lock_local_account("bob")
assert not result["success"]
assert "no account" in result["output"]
assert result["account"] is None
# -- what fails is said ---------------------------------------------------------------
@pytest.mark.parametrize("failing", ["getent", "id -Gn"])
def test_an_account_that_cannot_be_read_raises(host: _Host, driver: _Driver, failing: str) -> None:
_add_alice(host)
host.failing.add(failing)
with pytest.raises(RuntimeError, match="alice"):
driver.get_local_accounts(["alice"])
@pytest.mark.parametrize(
("failing", "step", "said"),
[
("rm -f", "sudo", "80-account-alice"),
("leavegroup", "sudo", "out of wheel"),
("as cat", "keys", "cannot read"),
("as install", "keys", "authorized_keys"),
("mktemp", "keys", "cannot stage"),
],
)
def test_a_step_that_fails_says_why(
host: _Host, driver: _Driver, failing: str, step: str, said: str
) -> None:
_add_alice(host, keys=OWN_KEY + "\n")
host.failing.add(failing)
result = driver.add_local_account("alice", ALICE_KEY)
failed = next(s for s in result["steps"] if s["step"] == step)
assert not failed["ok"] and said in failed["output"]
assert not result["success"]
def test_a_rule_that_cannot_be_installed_fails_the_step(host: _Host, driver: _Driver) -> None:
host.failing.add("install -m")
result = driver.add_local_account("alice", ALICE_KEY, password_hash=HASH, admin=True)
sudo = next(s for s in result["steps"] if s["step"] == "sudo")
assert not sudo["ok"] and "80-account-alice" in sudo["output"]
assert not [p for p in host.files if p.startswith("/tmp/")]
@pytest.mark.parametrize(
("failing", "ignored", "step", "said"),
[
({"lockuser"}, set(), "lock", "lockuser: failed"),
(set(), {"lockuser"}, "lock", "still not locked"),
({"as rm"}, set(), "keys", "cannot remove"),
(set(), {"as rm"}, "keys", "still has keys"),
],
)
def test_a_lock_that_did_not_take_says_so(
host: _Host, driver: _Driver, failing: set[str], ignored: set[str], step: str, said: str
) -> None:
_add_alice(host, keys=ALICE_KEY + "\n")
host.failing |= failing
host.ignored |= ignored
result = driver.lock_local_account("alice")
failed = next(s for s in result["steps"] if s["step"] == step)
assert not failed["ok"] and said in failed["output"]
assert not result["success"]
def test_an_account_that_cannot_be_read_back_is_said(host: _Host, driver: _Driver) -> None:
_add_alice(host)
host.failing.add("sudo -l")
result = driver.lock_local_account("alice")
assert result["account"] is None
assert "[read back] cannot ask sudo about alice" in result["output"]
# -- a key store of the driver's own ---------------------------------------------------
class _OwnKeyStore(_Driver):
"""A driver whose host keeps keys in a place of its own."""
def __init__(self, host: _Host) -> None:
super().__init__(host)
self.store: dict[str, list[str]] = {}
def _account_read_keys(self, name: str, home: str) -> list[str] | None:
return list(self.store.get(name, []))
def _account_add_key(self, name: str, home: str, public_key: str) -> FixStepOutcomeDict:
self.store.setdefault(name, []).append(f"{home} {public_key}")
return {"ok": True, "output": "stored"}
def _account_remove_keys(self, name: str, home: str) -> FixStepOutcomeDict:
self.store.pop(name, None)
return {"ok": True, "output": "dropped"}
def test_a_driver_can_keep_the_keys_elsewhere(host: _Host) -> None:
driver = _OwnKeyStore(host)
added = driver.add_local_account("alice", ALICE_KEY)
assert added["success"], added["output"]
assert driver.store == {"alice": [f"/home/alice {ALICE_KEY}"]}
assert added["account"] is not None
assert added["account"]["authorized_keys"] == [f"/home/alice {ALICE_KEY}"]
assert not [p for p in host.files if p.startswith("/home/")]
locked = driver.lock_local_account("alice")
assert locked["success"], locked["output"]
assert driver.store == {}
def test_a_key_file_the_host_adds_is_read_too(host: _Host) -> None:
class _ExtraFile(_Driver):
def _account_key_files(self, name: str, home: str) -> tuple[str, ...]:
return (*super()._account_key_files(name, home), f"/home/{name}/extra")
_add_alice(host, keys=OWN_KEY + "\n")
host.files["/home/alice/extra"] = ALICE_KEY + "\n"
[account] = _ExtraFile(host).get_local_accounts(["alice"])
assert account["authorized_keys"] == [OWN_KEY, ALICE_KEY]