Files
MeshTerm/meshterm/core/admin_store.py
T
Jean-Pierre MartineauandClaude Opus 5.5 4356bc9012 Forget passwords clears every stored admin password in one step
The reporter of #28 asked for a way to clear one or all of the stored admin
passwords. Del in the node picker forgets one. This adds the other: a
"Forget passwords" row in the Managed nodes section of the menu, behind the
red typed confirm (type FORGET), which names the nodes it will forget. It
also forgets the password of a node that is no longer a contact, which no
list shows. With nothing stored, it says so and asks nothing.

On the CLI it is `forget-admin-passwords --yes`: without --yes it is a usage
error, and with it the answer lists the nodes it forgot (NAME, LAST_LOGIN,
KEY). It exits 5 when nothing was stored, and works with no device.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 01:59:35 -05:00

212 lines
8.2 KiB
Python

# SPDX-License-Identifier: Apache-2.0
"""Storage for the admin passwords of remote nodes that MeshTerm remembers.
The remote-admin optimizer logs in to a repeater to adjust its TX power. When MeshTerm
stores the password, the user does not get a prompt at each run. This store is a small
JSON file in the config directory (``<config_dir>/admin.json``), the same as the
remembered device (:mod:`meshterm.core.device_store`). It is not in the SQLite database
of each invocation, because admin credentials are global state of the machine.
The store reads the file into :class:`AdminCredential` records, and it writes the file
from these records. It never writes back the raw JSON that it read. Thus a field that no
record knows is gone after the next write (refer to :data:`AdminCredential.RETIRED`).
The passwords are stored in plaintext. Thus the store writes the file with owner-only
permissions where the platform supports them. This store is a local tool for a user who
adjusts their own mesh. It is not a secret store for many users. Handle the file as a
local file that contains plaintext passwords.
"""
from __future__ import annotations
import json
from dataclasses import dataclass
from pathlib import Path
from typing import ClassVar
from .atomicwrite import write_atomically
from .models import Contact, LoginResult, utcnow
def admin_key(node: Contact) -> str:
"""Return the lookup key for the stored password of a node.
The function uses the full public key first, because it is stable and has only one
meaning. If there is no public key, it uses the key prefix, and then the name. Thus
MeshTerm can also remember a contact that has no key.
Args:
node: The contact for the lookup key.
Returns:
A normalized identifier in lower case.
"""
key = node.public_key or node.key_prefix or node.name
return key.lower().removeprefix("0x")
@dataclass(slots=True)
class AdminCredential:
"""A remembered admin password for one remote node.
Attributes:
key: The :func:`admin_key` under which the password is stored. It is the key of
the record in the file, not one of its fields.
password: The admin password of the node (plaintext).
label: A node name to show to the user.
last_used: The ISO-8601 timestamp of the last successful login.
"""
key: str
password: str
label: str
last_used: str
#: The fields that this record held before. It must never hold them again with another
#: meaning (refer to :data:`meshterm.core.preferences.RETIRED` for the reason that a
#: name is never used again).
RETIRED: ClassVar[frozenset[str]] = frozenset()
@classmethod
def read(cls, key: str, raw: object) -> AdminCredential | None:
"""Make a record from one file entry, or ``None`` when the entry has no password."""
if not isinstance(raw, dict) or raw.get("password") is None:
return None
return cls(
key=key,
password=str(raw["password"]),
label=str(raw.get("label") or ""),
last_used=str(raw.get("last_used") or ""),
)
def to_json(self) -> dict:
"""The record as the store writes it: its own fields, and no other data read with it."""
return {"password": self.password, "label": self.label, "last_used": self.last_used}
class AdminStore:
"""Reads and writes the admin passwords of remote nodes that MeshTerm remembers."""
def __init__(self, path: Path) -> None:
"""Open the store on the location of a JSON file.
Args:
path: The path to the JSON state file. The store makes the file at the first
write.
"""
self._path = path
def _load(self) -> dict[str, AdminCredential]:
"""Read all the credentials, by :func:`admin_key`.
The result is empty if the file is missing or corrupt.
"""
try:
data = json.loads(self._path.read_text(encoding="utf-8"))
except (OSError, ValueError):
return {}
if not isinstance(data, dict):
return {}
records = {}
for key, raw in data.items():
record = AdminCredential.read(str(key), raw)
if record is not None:
records[record.key] = record
return records
def get(self, node: Contact) -> str | None:
"""Return the remembered password for ``node``, or ``None`` if it is not stored.
Args:
node: The contact to find.
Returns:
The stored password, or ``None``.
"""
record = self._load().get(admin_key(node))
return record.password if record is not None else None
def remember(self, node: Contact, password: str) -> None:
"""Store (or change) the admin password for ``node``.
Args:
node: The contact that the password is for.
password: The admin password to remember.
"""
records = self._load()
key = admin_key(node)
records[key] = AdminCredential(
key=key, password=password, label=node.name, last_used=utcnow().isoformat()
)
self._write(records)
def record(self, node: Contact, password: str, outcome: LoginResult) -> None:
"""Change what MeshTerm remembers about ``node``, from the result of a login.
This method is the only credential policy. It is in one place because it was wrong
in five places. The store remembers a password when the node accepts it, and it
forgets the password when the node rejects it. When no reply came back, the store
keeps the password exactly as it is. No reply is not a refusal. Before, each caller
changed "refused" and "no reply" into the same ``False``, and forgot the password
in both cases. Thus, when the user opened the admin flow on a repeater that was
down at that time, MeshTerm deleted its password. The node sent nothing at all, and
MeshTerm read that silence as a refusal.
A stock node never refuses: it does not answer a wrong password. Thus a password
that the owner changed also stays here after its silence. The caller then offers a
new password, which replaces this one when the node accepts it (refer to
:mod:`meshterm.ui.admin_login`).
The callers still write their own messages (the sweep says "sweep again", the CLI
says "re-run"), but no caller makes this decision.
Args:
node: The contact that the login was for.
password: The password that was tried.
outcome: What the device reported.
"""
if outcome is LoginResult.ACCEPTED:
self.remember(node, password)
elif outcome is LoginResult.REFUSED:
self.forget(node)
def forget(self, node: Contact) -> None:
"""Delete the remembered password for ``node``, if there is one.
For example, use this method after the password stops working.
Args:
node: The contact to forget.
"""
records = self._load()
if records.pop(admin_key(node), None) is not None:
self._write(records)
def credentials(self) -> list[AdminCredential]:
"""Return all the remembered passwords, in the order of the file.
The list includes the password of a node that the device does not know any more,
because the store keys a password by the node and not by the contact list.
"""
return list(self._load().values())
def forget_all(self) -> list[AdminCredential]:
"""Delete all the remembered passwords.
Each next login asks for the password again. The method writes the file only when
it held a password.
Returns:
The credentials that the store forgot. The list is empty when the store held
none.
"""
records = self._load()
if records:
self._write({})
return list(records.values())
def _write(self, records: dict[str, AdminCredential]) -> None:
"""Store ``records`` atomically, with owner-only permissions where they are supported."""
data = {key: record.to_json() for key, record in records.items()}
write_atomically(self._path, json.dumps(data, indent=2), owner_only=True)