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")
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:
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: 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))