zc2 0.0.51

P2P compute broker with yen-denominated billing, WAL, and broker mesh support
#!/usr/bin/env python3
# Mirrored from zakuro-ai/zak-get scripts/minisign.py (GET-0013); keep in sync.
# Used by desktop-release.yml to sign the Tauri updater archive with the
# zakuro update key (ZAKURO_UPDATE_SIGNING_KEY), which Tauri cannot load
# itself because the key is stored unencrypted.
"""Minimal minisign (ed25519) for the signed zc manifests (GET-0013).

Compatible with minisign >= 0.10, rsign2, Rust `minisign-verify`, and Tauri's
updater (which uses minisign keys and signatures). Only what zak-get needs:

- unencrypted secret keys (kdf "\\0\\0"): the key lives in a CI secret, so a
  password would only sit next to it;
- prehashed signatures ("ED": ed25519 over BLAKE2b-512 of the message), the
  minisign default.

    minisign.py keygen <secret-key-out> <public-key-out>
    minisign.py sign <secret-key> <file> [trusted comment]   -> <file>.minisig
    minisign.py verify <public-key> <file> [<sig>]           exit 0 ok, 1 bad

The secret key may also come from $MINISIGN_SECRET_KEY (its file contents)
when <secret-key> is "-env".
"""

from __future__ import annotations

import base64
import hashlib
import os
import sys
import time

from cryptography.hazmat.primitives.asymmetric.ed25519 import (
    Ed25519PrivateKey,
    Ed25519PublicKey,
)
from cryptography.hazmat.primitives.serialization import (
    Encoding,
    NoEncryption,
    PrivateFormat,
    PublicFormat,
)

SIG_ALG = b"Ed"
PREHASHED_ALG = b"ED"
KDF_NONE = b"\x00\x00"
CKSUM_ALG = b"B2"


class MinisignError(ValueError):
    pass


def _b64_line(text: str, what: str) -> bytes:
    lines = [ln.strip() for ln in text.strip().splitlines() if ln.strip()]
    for ln in lines:
        if not ln.startswith("untrusted comment:") and not ln.startswith(
            "trusted comment:"
        ):
            try:
                return base64.b64decode(ln, validate=True)
            except ValueError as exc:
                raise MinisignError(f"{what}: invalid base64") from exc
    raise MinisignError(f"{what}: no key/signature line")


class SecretKey:
    def __init__(self, key_id: bytes, seed: bytes) -> None:
        if len(key_id) != 8 or len(seed) != 32:
            raise MinisignError("secret key: bad sizes")
        self.key_id = key_id
        self._sk = Ed25519PrivateKey.from_private_bytes(seed)

    @classmethod
    def generate(cls) -> SecretKey:
        sk = Ed25519PrivateKey.generate()
        seed = sk.private_bytes(Encoding.Raw, PrivateFormat.Raw, NoEncryption())
        return cls(os.urandom(8), seed)

    @classmethod
    def parse(cls, text: str) -> SecretKey:
        raw = _b64_line(text, "secret key")
        # sig_alg(2) kdf_alg(2) cksum_alg(2) salt(32) ops(8) mem(8)
        # | key_id(8) sk(64) checksum(32)
        if len(raw) != 158:
            raise MinisignError(f"secret key: {len(raw)} bytes, want 158")
        if raw[:2] != SIG_ALG:
            raise MinisignError("secret key: not an ed25519 minisign key")
        if raw[2:4] != KDF_NONE:
            raise MinisignError(
                "secret key is password-encrypted; store it unencrypted in the CI secret"
            )
        key_id, sk64, cksum = raw[54:62], raw[62:126], raw[126:158]
        if hashlib.blake2b(SIG_ALG + key_id + sk64, digest_size=32).digest() != cksum:
            raise MinisignError("secret key: checksum mismatch")
        key = cls(key_id, sk64[:32])
        if key.public_bytes() != sk64[32:]:
            raise MinisignError("secret key: public half does not match")
        return key

    def public_bytes(self) -> bytes:
        return self._sk.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw)

    def to_text(self) -> str:
        sk64 = (
            self._sk.private_bytes(Encoding.Raw, PrivateFormat.Raw, NoEncryption())
            + self.public_bytes()
        )
        cksum = hashlib.blake2b(SIG_ALG + self.key_id + sk64, digest_size=32).digest()
        raw = (
            SIG_ALG
            + KDF_NONE
            + CKSUM_ALG
            + bytes(32)
            + bytes(8)
            + bytes(8)
            + self.key_id
            + sk64
            + cksum
        )
        return (
            "untrusted comment: minisign secret key\n"
            + base64.b64encode(raw).decode()
            + "\n"
        )

    def public_key(self) -> PublicKey:
        return PublicKey(self.key_id, self.public_bytes())

    def sign(self, message: bytes, trusted_comment: str | None = None) -> str:
        if trusted_comment is None:
            trusted_comment = f"timestamp:{int(time.time())}"
        if "\n" in trusted_comment or "\r" in trusted_comment:
            raise MinisignError("trusted comment must be one line")
        digest = hashlib.blake2b(message, digest_size=64).digest()
        sig = self._sk.sign(digest)
        global_sig = self._sk.sign(sig + trusted_comment.encode())
        return (
            f"untrusted comment: signature from zak-get key {self.key_id[::-1].hex().upper()}\n"
            + base64.b64encode(PREHASHED_ALG + self.key_id + sig).decode()
            + "\n"
            + f"trusted comment: {trusted_comment}\n"
            + base64.b64encode(global_sig).decode()
            + "\n"
        )


class PublicKey:
    def __init__(self, key_id: bytes, pk: bytes) -> None:
        self.key_id = key_id
        self._pk = Ed25519PublicKey.from_public_bytes(pk)
        self._raw = pk

    @classmethod
    def parse(cls, text: str) -> PublicKey:
        raw = _b64_line(text, "public key")
        if len(raw) != 42 or raw[:2] != SIG_ALG:
            raise MinisignError("public key: not an ed25519 minisign key")
        return cls(raw[2:10], raw[10:42])

    def to_text(self) -> str:
        return (
            f"untrusted comment: minisign public key {self.key_id[::-1].hex().upper()}\n"
            + base64.b64encode(SIG_ALG + self.key_id + self._raw).decode()
            + "\n"
        )

    def verify(self, message: bytes, sig_text: str) -> str:
        """The trusted comment when `sig_text` is a valid signature of `message`."""
        lines = [ln.rstrip("\r") for ln in sig_text.strip().splitlines()]
        if len(lines) != 4 or not lines[2].startswith("trusted comment: "):
            raise MinisignError("signature: malformed")
        try:
            raw = base64.b64decode(lines[1], validate=True)
            global_sig = base64.b64decode(lines[3], validate=True)
        except ValueError as exc:
            raise MinisignError("signature: invalid base64") from exc
        if len(raw) != 74 or len(global_sig) != 64:
            raise MinisignError("signature: bad size")
        alg, key_id, sig = raw[:2], raw[2:10], raw[10:]
        if key_id != self.key_id:
            raise MinisignError("signature: made by a different key")
        if alg == PREHASHED_ALG:
            signed = hashlib.blake2b(message, digest_size=64).digest()
        elif alg == SIG_ALG:
            signed = message
        else:
            raise MinisignError("signature: unknown algorithm")
        trusted = lines[2][len("trusted comment: ") :]
        try:
            self._pk.verify(sig, signed)
            self._pk.verify(global_sig, sig + trusted.encode())
        except Exception as exc:  # cryptography raises InvalidSignature
            raise MinisignError("signature does not verify") from exc
        return trusted


def load_secret_key(arg: str) -> SecretKey:
    if arg == "-env":
        text = os.environ.get("MINISIGN_SECRET_KEY", "")
        if not text.strip():
            raise MinisignError("$MINISIGN_SECRET_KEY is empty")
        return SecretKey.parse(text)
    with open(arg) as fh:
        return SecretKey.parse(fh.read())


def main(argv: list[str]) -> int:
    if len(argv) >= 4 and argv[1] == "keygen":
        sk = SecretKey.generate()
        fd = os.open(argv[2], os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
        with os.fdopen(fd, "w") as fh:
            fh.write(sk.to_text())
        with open(argv[3], "w") as fh:
            fh.write(sk.public_key().to_text())
        return 0
    if len(argv) in (4, 5) and argv[1] == "sign":
        sk = load_secret_key(argv[2])
        with open(argv[3], "rb") as fh:
            msg = fh.read()
        with open(argv[3] + ".minisig", "w") as fh:
            fh.write(sk.sign(msg, argv[4] if len(argv) == 5 else None))
        return 0
    if len(argv) in (4, 5) and argv[1] == "verify":
        with open(argv[2]) as fh:
            pk = PublicKey.parse(fh.read())
        with open(argv[3], "rb") as fh:
            msg = fh.read()
        with open(argv[4] if len(argv) == 5 else argv[3] + ".minisig") as fh:
            sig = fh.read()
        try:
            print(pk.verify(msg, sig))
        except MinisignError as exc:
            print(f"minisign: {exc}", file=sys.stderr)
            return 1
        return 0
    print(__doc__, file=sys.stderr)
    return 2


if __name__ == "__main__":
    sys.exit(main(sys.argv))