Prove identity without revealing data. H33 generates ZK-STARK proofs in 2.0 microseconds and verifies them in 0.2 microseconds — no trusted setup, SHA3-256 post-quantum secure, integrated with FHE biometrics and Dilithium signatures.
Zero-knowledge authentication is a method of proving that a user holds valid credentials without transmitting or revealing those credentials to the verifier. The user generates a cryptographic proof; the server checks the proof and learns only that it is valid — never the secret behind it. This is a supporting expression of the ZK Platform, which proves without revealing. It exists because the moment a password or biometric leaves the client for server-side comparison, it becomes something an attacker can steal, phish, or harvest; a proof carries no such exposure. H33 implements this with ZK-STARK constructions — an external, standardized proof system H33 uses and implements, not one it invented or owns.
Traditional authentication sends credentials to a server for comparison. ZK authentication proves credential validity without transmitting the credentials themselves.
The user’s device generates a ZK-STARK proof that it possesses valid credentials matching the enrolled template. The proof is a compact cryptographic object — it proves knowledge of the secret without containing the secret. Generated in 2.0µs on commodity hardware.
H33’s server receives only the proof — never the credentials. It verifies the proof in 0.2µs using SHA3-256 hash commitments. If the proof is valid, the user is authenticated. The server learns nothing about the underlying data except that it is valid.
For biometric authentication, H33 combines ZK proofs with FHE. The biometric template is matched entirely in encrypted space (BFV lattice FHE), and the ZK proof attests to the match result. The server never sees the biometric — it only verifies the cryptographic proof of match.
After ZK verification, H33 signs the attestation with ML-DSA (Dilithium) — a NIST FIPS 204 post-quantum digital signature. The attestation is unforgeable even by quantum computers. It chains ZK proof + FHE result + Dilithium signature into a single verifiable token.
Both are zero-knowledge proof systems. The security properties differ significantly.
| Property | SNARKs | H33 STARKs |
|---|---|---|
| Trusted Setup | Required — ceremony compromise breaks all proofs | Not required — transparent, hash-derived parameters |
| Post-Quantum Security | No — relies on elliptic curve pairings | Yes — SHA3-256 hash-based, lattice-hard |
| Proof Size | ~200 bytes (smaller) | ~4 KB (larger, but PQ-secure) |
| Verification Speed | ~1–3ms (pairing operations) | 0.2µs (hash-only verification) |
| Proving Speed | 10–100ms (elliptic curve scalar mul) | 2.0µs (optimized hash pipeline) |
| Quantum Attack Surface | Shor’s algorithm breaks discrete-log assumption | No known quantum speedup for hash preimage |
| Audit Complexity | Requires trusting ceremony participants | Fully auditable — public parameters only |
Four stages, one API call. Every stage is post-quantum secure.
BFV inner product on 32 encrypted templates per ciphertext
Generate proof of valid match from encrypted result
DashMap cached lookup for repeat proofs, hash verify for new
ML-DSA sign + verify for post-quantum attestation token
Prove identity, verify the proof, and receive a post-quantum attestation — all in one API call.
// ZK auth: prove identity without exposing any data const result = await h33.authenticate({ biometric: capturedTemplate, // Encrypted client-side proofType: 'zk-stark', // SHA3-256 based securityLevel: 'h33-128', mode: 'standard' }); // result.verified → true / false // result.zkProof → ZK-STARK proof (SHA3-256) // result.attestation → Dilithium-signed attestation // result.proofTime → 2.0µs (prove) + 0.2µs (verify) // // Server NEVER sees biometric data // Server NEVER sees credential plaintext // Verifier receives only: valid / invalid + PQ attestation // Verify the attestation independently const valid = await h33.verifyAttestation({ attestation: result.attestation, publicKey: h33PublicKey // Dilithium public key }); // valid → true (ML-DSA signature verified)
ZK authentication proves a claim without revealing its secret. That is precise; so are its boundaries.
The verifier must confirm a credential is valid without ever holding it — passwordless login, biometric matching where the template must never leave encryption, privacy-preserving attribute checks, or any relying party that needs to verify a claim it should not be able to read. It layers behind an existing identity provider as the cryptographic verification step.
You need to compute over encrypted data rather than prove a claim about it — that is fully homomorphic encryption, handled by the FHE Platform. And ZK does not decide what an authenticated subject may do: authorization decisions are governed by Agent-008 under authority preserved by the Authority Center. ZK proves the claim; those systems act on it.
Proof vs. portable evidence. The ZK Platform generates the proof. The compact, offline-verifiable evidence you carry and re-verify anywhere is produced by H33-74 — ZK proves, H33-74 anchors. The Dilithium attestation shown above is signed with an external NIST FIPS 204 primitive that H33 implements, not one it owns.