Axiom flagship (3) — real hybrid Ed448+Dilithium5 certificate signing (G01) (#48)

## Summary

Closes the **authenticating‑signature half of G01** — the certificate
can now carry a *real* cryptographic signature, not just a forgeable
content digest. This is **opt‑in**: the default
`generate_certificate`/`save_certificate` path is byte‑for‑byte
unchanged (`authenticated=false`, SHA‑256 content digest), so nothing
downstream breaks.

Uses **only vetted primitives** (no hand‑rolled crypto), matching the
estate Trustfile scheme and the `pqcrypto` family `opsm` already ships.

### What's added
- **`crypto/` — new `axiom_crypto` Rust cdylib.** Ed448 via **OpenSSL
libcrypto**; Dilithium5 (ML‑DSA‑87 / FIPS 204) via
**`pqcrypto-dilithium`**. Clean C ABI (caller‑allocates + returned
length), minimal `unsafe` each with a `// SAFETY:` comment, 7 Rust
round‑trip/tamper/wrong‑key tests.
- **`src/verification/signing.jl`** — `Libdl` loader +
`generate_hybrid_keypair` / `hybrid_sign` / `hybrid_verify`.
Verification is **AND** — both Ed448 *and* Dilithium5 must verify (an
attacker must break both to forge). Includes a **runtime ABI
self‑check** that caught a real Dilithium5 signature‑length mismatch
(4627, not the 4595 first assumed) during development.
- **`certificates.jl`** — opt‑in `sign_certificate_hybrid` /
`verify_certificate_hybrid` / `save_certificate_hybrid`. Signs the
**SHA3‑512** digest (estate hashing standard) of the canonical content,
which **includes the properties list** so a claimed property can't be
added/removed without invalidating the signature.
- **`test/verification/hybrid_signing_tests.jl`** — real round‑trip +
**THE KEY ASSERTION**: a forger who knows the exact content and
recomputes the SHA3‑512 digest but lacks the private keys **cannot**
produce a signature that verifies against the victim's public keys (plus
a self‑verify sanity check proving it's authentication, not a crypto
malfunction).
- `Justfile` `build-crypto`/`test-crypto`; `ROADMAP.adoc` documents the
shipped capability and the **private‑key custody story** (HSM/offline
signer; public keys only in certificates; rotation/revocation explicitly
flagged as not‑yet‑implemented).

### Key‑management stance
**No private key material is committed anywhere** (verified).
Certificates embed only public keys; signing keys are generated
out‑of‑band.

## Verification (independent re‑run; crypto reviewed by hand)
- `cd crypto && cargo test --release` → **7/7 pass**.
- Built the cdylib, then `Pkg.test()` → **697 / 697 pass** (670 + 27
new), hybrid path actually executing (not skipped).
- Read `_hybrid_verify_digest` — confirmed **AND** semantics and real
`ccall` into the cdylib (no mock).
- Confirmed the forged‑certificate rejection assertion is genuine and
passing; confirmed no key files staged/untracked.

## Tracked follow‑ups
SPHINCS+ fallback tier; key rotation/revocation; the estate‑wide
Ed448‑vs‑Ed25519 reconciliation (`opsm` currently uses Ed25519 — flagged
for owner); wiring `build-crypto` into CI as part of the tier‑2 tooling
wave.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_01UPFC9YQ7g9gc3VnRox42Q1

---
_Generated by [Claude
Code](https://claude.ai/code/session_01UPFC9YQ7g9gc3VnRox42Q1)_

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

Justfile

@@ -47,6 +47,15 @@ build-backends: build-zig
 run-zig: build-zig
     AXIOM_ZIG_LIB=zig/zig-out/lib/libaxiom_zig.so julia --project=. -e 'using Axiom; println("Backend: ", typeof(current_backend()))'
 
+# Build the hybrid Ed448+Dilithium5 certificate-signing crypto shim (cdylib)
+build-crypto:
+    cd crypto && cargo build --release
+    @echo "Crypto shim built at crypto/target/release/libaxiom_crypto.so (or .dylib/.dll)"
+
+# Run the crypto shim's own Rust test suite (round-trip + tamper/wrong-key rejection)
+test-crypto:
+    cd crypto && cargo test --release
+
 # Check code quality
 lint:
     @echo "Checking editorconfig..."

ROADMAP.adoc

@@ -46,6 +46,18 @@ Must progress snapshot (2026-02-16):
 * [x] Added in-tree gRPC unary protobuf binary-wire support (`application/grpc`) with JSON bridge fallback (`application/grpc+json`).
 * [x] Added direct `.pt/.pth/.ckpt` import bridge and expanded ONNX export coverage (Dense/Conv/Norm/Pool + activations).
 * [x] Added consolidated readiness gate script for local/CI release checks: `scripts/readiness-check.sh`.
+* [x] Added REAL authenticating hybrid Ed448+Dilithium5 (ML-DSA-87) certificate
+  signing (G01, opt-in): Rust `cdylib` shim in `crypto/` (`pqcrypto-dilithium`
+  for Dilithium5, system libcrypto via the `openssl` crate for Ed448 — no
+  hand-rolled cryptography) exposed to Julia via `Libdl`/`ccall` in
+  `src/verification/signing.jl`; `sign_certificate_hybrid` /
+  `verify_certificate_hybrid` / `save_certificate_hybrid` in
+  `src/verification/certificates.jl`; content is hashed with SHA3-512 (estate
+  hashing standard) before signing. The *default* `generate_certificate` /
+  `save_certificate` path is unchanged (still an unkeyed SHA-256 content
+  digest, `authenticated=false`) — hybrid signing is strictly additive and
+  opt-in. See `crypto/README.md` for the C ABI and `test/verification/hybrid_signing_tests.jl`
+  for the forged-signature-rejection proof.
 
 === Should
 
@@ -87,6 +99,41 @@ Readiness verification (2026-02-17): `scripts/readiness-check.sh` => Passed: 29,
 
 See link:docs/wiki/Roadmap-Commitments.md[docs/wiki/Roadmap-Commitments.md] for staged targets and acceptance criteria.
 
+== Certificate Signing: Private Key Custody
+
+The hybrid Ed448+Dilithium5 signing capability (`crypto/`,
+`src/verification/signing.jl`) authenticates certificate *content*; it does
+not, by itself, solve *key custody*. That is an operational concern, tracked
+here explicitly rather than left implicit:
+
+* **Private keys are never generated by, stored in, or committed to this
+  repository.** `generate_hybrid_keypair()` exists only for tests/examples
+  and produces keys held purely in-memory for the lifetime of that process.
+* **Real signing keys are provisioned out-of-band.** The intended custody
+  model is an HSM (hardware security module) or an offline/air-gapped signing
+  workstation: the private Ed448 and Dilithium5 keys are generated there,
+  never leave that boundary, and every real certificate signature is produced
+  by sending the certificate's canonical content (or its SHA3-512 digest) to
+  that boundary and receiving back a `HybridSignature` — the private keys
+  themselves are never loaded into the same process that runs model
+  training/verification.
+* **Only public keys are ever embedded in a certificate.** `save_certificate_hybrid`
+  and `hybrid_signature_to_dict` only ever serialize the public Ed448 and
+  Dilithium5 keys (hex-encoded) alongside the signature values, so that
+  verification is self-contained without needing to distribute or trust a
+  separate keyring file.
+* **Key rotation / revocation is not yet implemented** — there is currently no
+  certificate-transparency-style log or revocation list for hybrid signing
+  public keys; a verifier that trusts a given public key trusts every
+  certificate signed by it until a rotation policy is added. This is an
+  explicit gap, not an oversight, and is a natural follow-on once an HSM/offline
+  signer is actually provisioned in a deployment.
+* **`.gitignore` enforces this at the file level** as defence in depth
+  (`*.pem`, `*.key`, `secrets/` are ignored both at the repo root and inside
+  `crypto/`), but the real control is procedural: nobody should ever generate
+  a real signing key inside a working copy of this repository in the first
+  place.
+
 == Definition of Done for "Production Ready"
 
 . Clean `instantiate/build/precompile/test` on supported Julia versions

crypto/.gitignore

@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: MPL-2.0
+# Rust build output — never commit compiled artifacts or private key material.
+target/
+Cargo.lock.bak
+
+# Defence-in-depth: this crate must never see a private key on disk during
+# normal use (keys are generated in-memory by tests, or out-of-band by an
+# HSM/offline process for real signing), but block common accidental paths
+# just in case.
+*.pem
+*.key
+secrets/

crypto/Cargo.lock

@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: MPL-2.0
+[package]
+name = "axiom_crypto"
+version = "0.1.0"
+authors = ["Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>"]
+edition = "2021"
+description = "Hybrid Ed448 + Dilithium5 (ML-DSA-87) certificate signing for Axiom.jl (estate Trustfile scheme)"
+license = "MPL-2.0"
+publish = false
+
+[lib]
+name = "axiom_crypto"
+path = "src/lib.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+openssl = "0.10"
+pqcrypto-dilithium = "0.5"
+pqcrypto-traits = "0.3"
+
+[profile.release]
+# Keep panics as aborts out of the FFI boundary story simple: every exported
+# fn is written to catch errors internally and return a status code instead
+# of unwinding across the C ABI, but `panic = "abort"` is a defence in depth
+# backstop in case a bug slips through (unwinding across FFI is UB).
+panic = "abort"