matrixscroll 0.2.4__tar.gz → 0.2.5__tar.gz

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to the Matrix Scroll Python SDK are documented here. The
 format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
 this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.5] - 2026-06-24
+
+Post-HN patch: GitHub gpgsig commit binding, SE050 mock transport, YubiKey pubkey export, Rekor/GUAC CLI MVP.
+
+### Added
+- **GitHub `gpgsig` commit binding** — verify envelopes against raw commit object SHA when OpenPGP signatures are present.
+- **SE050 mock transport** — `MATRIXSCROLL_SE050_MOCK=1` enables `HardwareProvider` for development (`providers/se050_transport.py`).
+- **YubiKey public key export** — PKCS#11 EC public key read path (mock + real token).
+- **GUAC export CLI** — `matrixscroll envelope-export-guac --bundle DIR --output guac.jsonl`.
+- **Rekor publish stub** — `matrixscroll envelope-publish-rekor --bundle DIR` (dry-run artifacts; optional `--rekor-cli`).
+
+### Fixed
+- **`parse_commit()` / envelope verify** on GitHub-signed commits with multi-line `gpgsig` headers (Windows CRLF safe).
+
 ## [0.2.4] - 2026-06-20
 
 Who-Acted gate productization: attribution policy, delegation schema, CI hardening.

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/CONTRIBUTING.md

@@ -29,6 +29,25 @@ pip install -e ".[dev]"
 pytest -q
 ```
 
+## Commit envelope provenance (Scroll Gate)
+
+For PRs that include agent-assisted commits, publish signed commit envelopes to git notes:
+
+```bash
+matrixscroll hook-install
+export MATRIXSCROLL_ACTOR_TYPE=agent   # or human / ci as appropriate
+export MATRIXSCROLL_TOOL=cursor        # or your IDE / agent tool name
+git commit -m "feat: your change"
+matrixscroll envelope-publish-notes --base origin/main --head HEAD
+git push origin refs/notes/matrixscroll
+```
+
+CI verifies the PR range with `matrixscroll envelope-verify-range --source notes`.
+Until repository variable `ENFORCE_PROVENANCE=true` is set, missing notes produce a **warning**
+in the GitHub Step Summary rather than a hard failure.
+
+Optional policy file for release branches: [`.github/trusted-keys.json`](.github/trusted-keys.json).
+
 ## Running the conformance vectors
 
 ```bash
@@ -42,7 +61,7 @@ vectors are welcome.
 
 ## Pull request checklist
 
-- [ ] Tests pass locally (`pytest -q`).
+- [ ] For agent-assisted commits: publish envelope git notes (`envelope-publish-notes` + push `refs/notes/matrixscroll`).
 - [ ] New public API has a docstring and is re-exported from
       `matrixscroll/__init__.py` if it's part of the supported surface.
 - [ ] `CHANGELOG.md` updated with a dated version entry (see Keep a Changelog format).

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrixscroll
-Version: 0.2.4
+Version: 0.2.5
 Summary: Open protocol for signing AI-assisted code provenance with Ed25519; shipping software root of trust with SSX360 hardware support in progress.
 Project-URL: Homepage, https://matrixscroll.com
 Project-URL: Documentation, https://matrixscroll.com/docs
@@ -32,7 +32,9 @@ Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == 'dev'
 Requires-Dist: pytest>=7.4; extra == 'dev'
 Provides-Extra: git
+Provides-Extra: tpm
 Provides-Extra: yubikey
+Requires-Dist: python-pkcs11>=0.7; extra == 'yubikey'
 Description-Content-Type: text/markdown
 
 # Matrix Scroll

matrixscroll-0.2.5/docs/CI_HARD_GATE.md

@@ -0,0 +1,49 @@
+# CI hard gate — Scroll Gate Phase C
+
+Enable required provenance on `SSX360/matrixscroll` after contributors can publish git notes.
+
+## 1. Repository variable
+
+```bash
+gh variable set ENFORCE_PROVENANCE --body true --repo SSX360/matrixscroll
+```
+
+When set, [`verify-manifest.yml`](.github/workflows/verify-manifest.yml) **fails** PRs missing `refs/notes/matrixscroll` envelopes.
+
+## 2. Branch protection
+
+In GitHub → Settings → Branches → `main`:
+
+- Require status check: **Verify Matrix Scroll manifest**
+- Require branches up to date before merging
+
+```bash
+gh api repos/SSX360/matrixscroll/branches/main/protection \
+  --method PUT \
+  -f required_status_checks[strict]=true \
+  -f required_status_checks[checks][][context]='Verify Matrix Scroll manifest' \
+  -f enforce_admins=false \
+  -f required_pull_request_reviews[required_approving_review_count]=0
+```
+
+Adjust review count to match your team policy.
+
+## 3. Contributor flow
+
+Every PR must:
+
+```bash
+matrixscroll envelope-publish-notes --base origin/main --head HEAD
+git push origin refs/notes/matrixscroll
+matrixscroll envelope-verify-range --base origin/main --head HEAD --source notes
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Rollback
+
+```bash
+gh variable set ENFORCE_PROVENANCE --body false --repo SSX360/matrixscroll
+```
+
+Soft gate resumes (warning only in Step Summary).

matrixscroll-0.2.5/docs/hardware-provider.md

@@ -0,0 +1,38 @@
+# SSX360 hardware provider (L2)
+
+**Status:** Mock transport available — set `MATRIXSCROLL_SE050_MOCK=1` for development.
+Real I2C firmware ships when Pico 2 + OM-SE050ARD-E kits are on the bench.
+
+## Quickstart (mock)
+
+```powershell
+$env:MATRIXSCROLL_MODE = "hardware"
+$env:MATRIXSCROLL_SE050_MOCK = "1"
+matrixscroll status
+```
+
+## Planned behavior
+
+- `MATRIXSCROLL_MODE=hardware` selects the secure-element provider
+- Private keys never leave the SE050; no seed on disk
+- User-presence touch gating for protected-branch commits
+- Compatible with the same manifest and commit-envelope schemas as L1 emulated mode
+
+## Environment variables
+
+| Variable | Purpose |
+|----------|---------|
+| `MATRIXSCROLL_MODE=hardware` | Select hardware provider |
+| `MATRIXSCROLL_SE050_MOCK=1` | Use in-process Ed25519 mock transport (dev/CI) |
+
+Firmware scaffold: [`launch/firmware/ssx360-se050/README.md`](../../launch/firmware/ssx360-se050/README.md)
+
+## Related docs
+
+- [`docs/yubikey-bridge.md`](yubikey-bridge.md) — bridge path before SSX360 GA
+- [`launch/reference-architecture-se050-rp2350.md`](../../launch/reference-architecture-se050-rp2350.md)
+- [`SPEC.md`](../SPEC.md) — wire format (unchanged for L2 signing algorithm)
+
+## Device
+
+Reference hardware: [matrixscroll.com/device](https://matrixscroll.com/device)

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/docs/rekor-guac-bridge-design.md

@@ -1,6 +1,6 @@
 # Rekor / GUAC envelope bridge (design)
 
-> Status: design RFC for Phase 3. Not implemented.
+> Status: MVP shipped in v0.2.5 (`envelope-export-guac`, `envelope-publish-rekor` dry-run).
 
 ## Goal
 

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/docs/yubikey-bridge.md

@@ -123,6 +123,20 @@ Add to SPEC.md when PIV bridge ships:
 
 Conformance vectors required before enabling in release CI.
 
+## device_id derivation
+
+YubiKey envelopes use the same `MS-XXXX-YYYY` format as emulated mode:
+
+```
+device_id = "MS-" + sha256(public_key_der)[:8] uppercased with hyphen at position 4
+```
+
+Implementation: [`matrixscroll/providers/emulated.py`](../matrixscroll/providers/emulated.py) `device_id()`.
+
+Public key bytes come from PKCS#11 EC key export (or mock P-256 key when `MATRIXSCROLL_YKCS11_MOCK=1`).
+
+Manual smoke test: [`docs/yubikey-smoke.md`](yubikey-smoke.md)
+
 ## Test plan
 
 1. Unit: mock PKCS#11 session returns fixed signature → verify path

matrixscroll-0.2.5/docs/yubikey-smoke.md

@@ -0,0 +1,35 @@
+# YubiKey manual smoke test
+
+Requires a YubiKey 5 with PIV EC key and [Yubico PKCS#11 module](https://www.yubico.com/support/download/yubikey-manager/) installed.
+
+## Linux / macOS
+
+```bash
+export MATRIXSCROLL_MODE=yubikey
+export MATRIXSCROLL_YKCS11_MODULE=/usr/lib/x86_64-linux-gnu/libykcs11.so  # adjust path
+export MATRIXSCROLL_PIV_PIN='your-pin'
+
+matrixscroll status
+matrixscroll sign vectors/valid_simple.json
+matrixscroll verify vectors/valid_simple.json
+```
+
+## Windows
+
+```powershell
+$env:MATRIXSCROLL_MODE = "yubikey"
+$env:MATRIXSCROLL_YKCS11_MODULE = "C:\Program Files\Yubico\Yubico PIV Tool\bin\ykcs11.dll"
+$env:MATRIXSCROLL_PIV_PIN = "your-pin"
+
+matrixscroll status
+```
+
+## Mock (no hardware)
+
+```powershell
+$env:MATRIXSCROLL_MODE = "yubikey"
+$env:MATRIXSCROLL_YKCS11_MOCK = "1"
+python -m pytest tests/test_yubikey_provider.py -q
+```
+
+Expected: `algorithm: ecdsa-p256`, `mode: yubikey`, verify passes.

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/matrixscroll/__init__.py

@@ -38,7 +38,7 @@ from ._core import (
     verify_manifest,
 )
 
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 
 __all__ = [
     "ALGORITHM",

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/matrixscroll/cli.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import subprocess
 import sys
 from pathlib import Path
 
@@ -168,6 +169,35 @@ def _cmd_sign(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_envelope_export_guac(args: argparse.Namespace) -> int:
+    from . import guac_export as guac_mod
+
+    try:
+        result = guac_mod.export_guac_jsonl(Path(args.bundle), Path(args.output))
+    except (RuntimeError, FileNotFoundError, ValueError) as exc:
+        print(json.dumps({"ok": False, "error": str(exc)}))
+        return 1
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result.get("ok") else 2
+
+
+def _cmd_envelope_publish_rekor(args: argparse.Namespace) -> int:
+    from . import rekor_publish as rekor_mod
+
+    bundle = Path(args.bundle)
+    try:
+        if args.rekor_cli:
+            result = rekor_mod.publish_rekor_cli(bundle, rekor_url=args.rekor_url or None)
+        else:
+            out = Path(args.output) if args.output else bundle / ".rekor-dry-run"
+            result = rekor_mod.publish_rekor_dry_run(bundle, out)
+    except (RuntimeError, FileNotFoundError, subprocess.CalledProcessError) as exc:
+        print(json.dumps({"ok": False, "error": str(exc)}))
+        return 1
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result.get("ok") else 2
+
+
 def _cmd_envelope_export(args: argparse.Namespace) -> int:
     if _gate is None:
         print(json.dumps({"ok": False, "error": "gate module unavailable"}))
@@ -357,6 +387,28 @@ def build_parser() -> argparse.ArgumentParser:
     _add_policy_args(env_verify_range)
     env_verify_range.set_defaults(command="envelope-verify-range")
 
+    guac_export = sub.add_parser(
+        "envelope-export-guac",
+        help="Export verified envelopes from a bundle to GUAC JSONL",
+    )
+    guac_export.add_argument("--bundle", required=True, help="Envelope bundle directory")
+    guac_export.add_argument("--output", "-o", required=True, help="Output JSONL path")
+    guac_export.set_defaults(command="envelope-export-guac")
+
+    rekor_pub = sub.add_parser(
+        "envelope-publish-rekor",
+        help="Publish envelopes to Rekor (dry-run by default)",
+    )
+    rekor_pub.add_argument("--bundle", required=True, help="Envelope bundle directory")
+    rekor_pub.add_argument("--output", "-o", default="", help="Dry-run output directory")
+    rekor_pub.add_argument(
+        "--rekor-cli",
+        action="store_true",
+        help="Upload via rekor-cli (requires REKOR_URL)",
+    )
+    rekor_pub.add_argument("--rekor-url", default="", help="Rekor server URL override")
+    rekor_pub.set_defaults(command="envelope-publish-rekor")
+
     return parser
 
 
@@ -377,6 +429,8 @@ def main(argv: list[str] | None = None) -> int:
         "envelope-publish-notes": _cmd_envelope_publish_notes,
         "envelope-fetch-notes": _cmd_envelope_fetch_notes,
         "envelope-verify-range": _cmd_envelope_verify_range,
+        "envelope-export-guac": _cmd_envelope_export_guac,
+        "envelope-publish-rekor": _cmd_envelope_publish_rekor,
     }
     handler = handlers.get(args.command)
     if handler is None:

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/matrixscroll/git.py

@@ -34,6 +34,24 @@ def _run_git(*args: str, cwd: Path | None = None, strip: bool = True) -> str:
     return result.stdout
 
 
+def _run_git_bytes(*args: str, cwd: Path | None = None) -> bytes:
+    result = subprocess.run(
+        ["git", *args],
+        capture_output=True,
+        check=False,
+        cwd=cwd,
+    )
+    if result.returncode != 0:
+        err = (result.stderr or result.stdout or b"").decode("utf-8", errors="replace").strip()
+        raise RuntimeError(err or "git command failed")
+    return result.stdout
+
+
+def _commit_object_sha(raw: bytes) -> str:
+    wrapped = b"commit " + str(len(raw)).encode("ascii") + b"\0" + raw
+    return hashlib.sha1(wrapped, usedforsecurity=False).hexdigest()
+
+
 def repo_root() -> Path:
     return Path(_run_git("rev-parse", "--show-toplevel"))
 
@@ -127,15 +145,19 @@ def _parse_identity_line(line: str) -> dict[str, str]:
     return {"name": name, "email": email, "date": f"{timestamp} {tz}"}
 
 
-def parse_commit(sha: str, root: Path | None = None) -> dict[str, Any]:
-    root = root or repo_root()
-    commit_sha = _run_git("rev-parse", sha, cwd=root)
-    raw = _run_git("cat-file", "commit", commit_sha, cwd=root, strip=False)
+def _commit_headers_and_body(raw: str) -> tuple[str, list[str], dict[str, str], dict[str, str], str]:
+    """Parse a raw commit object, including multi-line ``gpgsig`` headers."""
+    lines = raw.split("\n")
     tree = ""
     parents: list[str] = []
     author: dict[str, str] | None = None
     committer: dict[str, str] | None = None
-    for line in raw.splitlines():
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        if line == "":
+            i += 1
+            break
         if line.startswith("tree "):
             tree = line.split(" ", 1)[1]
         elif line.startswith("parent "):
@@ -144,18 +166,37 @@ def parse_commit(sha: str, root: Path | None = None) -> dict[str, Any]:
             author = _parse_identity_line(line)
         elif line.startswith("committer "):
             committer = _parse_identity_line(line)
-    if not tree or author is None or committer is None or "\n\n" not in raw:
-        raise RuntimeError(f"unexpected commit object for {sha}")
-    body = raw.split("\n\n", 1)[1]
-    actual_id = compute_commit_id(
-        tree=tree,
-        parents=parents,
-        author=author,
-        committer=committer,
-        message=body,
-    )
-    if actual_id != commit_sha:
-        raise RuntimeError(f"commit id mismatch for {sha}")
+        elif line.startswith("gpgsig "):
+            i += 1
+            while i < len(lines) and lines[i].startswith(" "):
+                i += 1
+            continue
+        i += 1
+    if not tree or author is None or committer is None:
+        raise RuntimeError("unexpected commit object headers")
+    body = "\n".join(lines[i:])
+    return tree, parents, author, committer, body
+
+
+def parse_commit(sha: str, root: Path | None = None) -> dict[str, Any]:
+    root = root or repo_root()
+    commit_sha = _run_git("rev-parse", sha, cwd=root)
+    raw_bytes = _run_git_bytes("cat-file", "commit", commit_sha, cwd=root)
+    if _commit_object_sha(raw_bytes) != commit_sha:
+        raise RuntimeError(f"commit object hash mismatch for {sha}")
+    raw = raw_bytes.decode("utf-8").replace("\r\n", "\n")
+    tree, parents, author, committer, body = _commit_headers_and_body(raw)
+    has_gpgsig = any(line.startswith("gpgsig ") for line in raw.split("\n"))
+    if not has_gpgsig:
+        actual_id = compute_commit_id(
+            tree=tree,
+            parents=parents,
+            author=author,
+            committer=committer,
+            message=body,
+        )
+        if actual_id != commit_sha:
+            raise RuntimeError(f"commit id mismatch for {sha}")
     return {
         "actual_id": commit_sha,
         "tree": tree,

matrixscroll-0.2.5/matrixscroll/guac_export.py

@@ -0,0 +1,78 @@
+"""Export verified commit envelopes to GUAC-compatible JSONL (Phase 3 MVP)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .gate import BUNDLE_INDEX, verify_commit_envelope_for_sha
+from .git import _repository_info, repo_root
+
+PREDICATE_TYPE = "https://matrixscroll.com/attestation/commit-envelope/v1"
+
+
+def _load_bundle_index(bundle_dir: Path) -> dict[str, Any]:
+    index_path = bundle_dir / BUNDLE_INDEX
+    if not index_path.is_file():
+        raise FileNotFoundError(f"bundle index missing: {index_path}")
+    return json.loads(index_path.read_text(encoding="utf-8-sig"))
+
+
+def envelope_to_guac_statement(
+    envelope: dict[str, Any],
+    *,
+    sha: str,
+    repo_name: str,
+) -> dict[str, Any]:
+    """Build one in-toto / GUAC-adjacent attestation object."""
+    return {
+        "_type": "https://in-toto.io/Statement/v1",
+        "predicateType": PREDICATE_TYPE,
+        "subject": [{"name": f"{repo_name}@{sha}", "digest": {"sha1": sha}}],
+        "predicate": envelope,
+    }
+
+
+def export_guac_jsonl(
+    bundle_dir: Path,
+    output: Path,
+    *,
+    root: Path | None = None,
+) -> dict[str, Any]:
+    """Verify each envelope in a bundle and write GUAC-ingestible JSONL."""
+    root = root or repo_root()
+    index = _load_bundle_index(bundle_dir)
+    repo_info = index.get("repository") or _repository_info(root)
+    repo_name = str(repo_info.get("remote_url") or repo_info.get("root") or "unknown")
+
+    commits = index.get("commits") or []
+    exported: list[str] = []
+    skipped: list[dict[str, str]] = []
+
+    lines: list[str] = []
+    for sha in commits:
+        path = bundle_dir / f"{sha}.json"
+        if not path.is_file():
+            skipped.append({"sha": sha, "error": "envelope file missing"})
+            continue
+        envelope = json.loads(path.read_text(encoding="utf-8-sig"))
+        result = verify_commit_envelope_for_sha(envelope, sha, root=root)
+        if not result.ok:
+            skipped.append({"sha": sha, "error": result.error or "verification failed"})
+            continue
+        statement = envelope_to_guac_statement(envelope, sha=sha, repo_name=repo_name)
+        lines.append(json.dumps(statement, sort_keys=True, separators=(",", ":")))
+        exported.append(sha)
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8")
+
+    return {
+        "ok": len(skipped) == 0,
+        "schema": "matrixscroll.guac_export.v1",
+        "output": str(output),
+        "exported": len(exported),
+        "skipped": skipped,
+        "commits": exported,
+    }

matrixscroll-0.2.5/matrixscroll/manifest.py

@@ -0,0 +1,101 @@
+"""Manifest signing and verification."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import copy
+import hashlib
+import time
+from typing import Any
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric.utils import Prehashed
+
+from .canonical import canonical_bytes
+from .constants import ALGORITHM, SIGNATURE_SCHEMA
+from .providers.emulated import device_id
+from .providers.registry import get_provider, identity_info, verify
+
+
+def _provider_algorithm(provider) -> str:
+    return getattr(provider, "algorithm", ALGORITHM)
+
+
+def sign_manifest(
+    manifest: dict[str, Any], provider=None
+) -> dict[str, Any]:
+    provider = provider or get_provider()
+    info = identity_info(provider)
+    signed = copy.deepcopy(manifest)
+    signed.pop("signature", None)
+    canonical = canonical_bytes(signed)
+    signing_input = provider.signing_input(canonical) if hasattr(provider, "signing_input") else canonical
+    signature_value = base64.b64encode(provider.sign(signing_input)).decode("ascii")
+    algorithm = _provider_algorithm(provider)
+    block: dict[str, Any] = {
+        "schema": SIGNATURE_SCHEMA,
+        "algorithm": algorithm,
+        "device_id": info["device_id"],
+        "public_key": info["public_key"],
+        "mode": info["mode"],
+        "signed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "value": signature_value,
+    }
+    digest = getattr(provider, "digest", None)
+    if digest:
+        block["digest"] = digest
+    signed["signature"] = block
+    return signed
+
+
+def _verify_ecdsa_p256(public_key: bytes, data: bytes, signature: bytes, digest: str | None) -> bool:
+    try:
+        from cryptography.hazmat.primitives.serialization import load_der_public_key
+
+        key = load_der_public_key(public_key)
+        if not isinstance(key, ec.EllipticCurvePublicKey):
+            return False
+        payload = hashlib.sha256(data).digest() if digest == "sha256" else data
+        key.verify(signature, payload, ec.ECDSA(Prehashed(hashes.SHA256())))
+        return True
+    except (InvalidSignature, ValueError, TypeError):
+        return False
+
+
+def verify_manifest(manifest: dict[str, Any]) -> bool:
+    if not isinstance(manifest, dict):
+        return False
+    block = manifest.get("signature")
+    if not isinstance(block, dict):
+        return False
+    if block.get("schema") != SIGNATURE_SCHEMA:
+        return False
+    algorithm = block.get("algorithm", ALGORITHM)
+    public_key = block.get("public_key")
+    signature = block.get("value")
+    if not isinstance(public_key, str) or not isinstance(signature, str):
+        return False
+    try:
+        public_key_bytes = base64.b64decode(public_key.encode("ascii"), validate=True)
+        signature_bytes = base64.b64decode(signature.encode("ascii"), validate=True)
+    except (ValueError, binascii.Error):
+        return False
+    if block.get("device_id") != device_id(public_key_bytes):
+        return False
+    try:
+        signing_input = canonical_bytes(manifest)
+    except (TypeError, ValueError):
+        return False
+    if algorithm == "ecdsa-p256":
+        return _verify_ecdsa_p256(
+            public_key_bytes,
+            signing_input,
+            signature_bytes,
+            block.get("digest") if isinstance(block.get("digest"), str) else "sha256",
+        )
+    if algorithm != ALGORITHM:
+        return False
+    return verify(public_key_bytes, signing_input, signature_bytes)

{matrixscroll-0.2.4 → matrixscroll-0.2.5}/matrixscroll/providers/base.py

@@ -9,6 +9,8 @@ class IdentityProvider(ABC):
     """A root-of-trust provider. Signing happens here; keys never escape."""
 
     mode: str = "unknown"
+    algorithm: str = "ed25519"
+    digest: str | None = None
 
     @abstractmethod
     def public_key_bytes(self) -> bytes:
@@ -18,6 +20,10 @@ class IdentityProvider(ABC):
     def sign(self, data: bytes) -> bytes:
         ...
 
+    def signing_input(self, canonical: bytes) -> bytes:
+        """Transform canonical manifest bytes before signing."""
+        return canonical
+
     @property
     def created_at(self) -> str:
         return ""