Proof and documentation
ZAPLink: Sealed Agent-to-Agent Transport
What the ZAPLink sealed transport carries, the standardized primitives behind it, the measured latency and seal evidence, and the one honest limitation stated up front.
What it is
ZAPLink is a post-quantum-sealed, mutually authenticated agent-to-agent channel. It carries a message between two software agents that is encrypted and signed before it leaves the sender, so the two parties exchange authenticated, confidential payloads without opening an interactive login session and without SSH. The demonstration measures how long a sealed, signed delivery takes end to end and compares it against the common transports a team already uses: HTTPS/TLS, SFTP/FTPS, and SMTP with STARTTLS.
What ZAPLink replaces is the habit of reaching for SSH or a bespoke TLS service to move a machine-to-machine message. It is a delivery transport for sealed payloads, not a session protocol.
What this proves to you (plain English)
- Two systems can exchange a message that is both encrypted and signed with post-quantum algorithms, and the cryptography is cheap enough that it is not what makes the message slow.
- Adding a post-quantum seal and a signature does not cost you a round-trip penalty. In our lab the sealed, signed delivery landed in roughly a third of the time an HTTPS/TLS exchange took, because the slow part of TLS is the handshake negotiation, and ZAPLink does not perform one on the critical path.
- We state an honest limitation up front (see part d): the current channel does not yet provide forward secrecy. A post-quantum label on a channel that lacks forward secrecy would be a trust story the artifact does not support, so we say so plainly rather than let the speed number imply a property the transport does not have.
Standards and parameters
ZAPLink is built from NIST-standardized, publicly specified primitives. No proprietary algorithm is required to understand or to trust what the channel does.
| Role | Primitive | Standard | Public parameter facts |
|---|---|---|---|
| Key establishment (seal) | ML-KEM-1024 | FIPS 203 | public key 1568 B, ciphertext 1568 B, shared secret 32 B |
| Signature (authenticate) | ML-DSA (Dilithium family) | FIPS 204 | e.g. ML-DSA-65 public key 1952 B, signature 3309 B; ML-DSA-87 public key 2592 B, signature 4627 B |
| Symmetric seal | AES-256-GCM | FIPS 197 + SP 800-38D | 16-byte authentication tag; unique nonce per seal |
| Hashing / derivation | SHA-3 / SHAKE | FIPS 202 | used for digest and derivation |
Context (public): NIST published the three PQC standards on 2026-08-13 (FIPS 203 ML-KEM, FIPS 204 ML-DSA, FIPS 205 SLH-DSA). Executive Order 14412 and CNSA 2.0 set the federal migration mandate toward these algorithms. [FACT, public standards]
Parameter sizes above are the published FIPS parameter-set sizes and were reproduced in our own measurement run (zaplink_proof.json, 2026-10-23). [FACT, public + reproduced on our bench]
Correctness and behavior evidence
Graded FACT where measured on our bench (one lab host, 2026-10-23, source in the proof pack); INFERENCE where it is a reasoned consequence.
- Round-trip integrity: a payload sealed and signed by the sender is opened and verified by the recipient; a legitimate message is delivered and read back intact. [FACT, our bench]
- The sealed output is indistinguishable from random to standard statistical tests, which is what a correct seal should produce regardless of the input:
- ciphertext entropy 7.9973 bits per byte (ideal is ~8.0), against a low-by-design plaintext entropy of 3.7150; [FACT, our bench]
- ciphertext compressibility 1.0004 (above 0.98 means no exploitable structure remains); [FACT, our bench]
- chi-square versus uniform 240.4 with 255 degrees of freedom (near the ideal ~255); [FACT]
- a known plaintext canary was NOT found anywhere in the ciphertext; [FACT, our bench]
- 40 of 40 seals used distinct nonces (a nonce repeat under one key would break GCM). [FACT]
- Tamper rejection: altered, truncated, or spliced deliveries are rejected rather than accepted, and a legitimate delivery is accepted. The behavior was exercised against a battery of malformed and forged inputs and every case was handled as expected. [FACT, our bench; mechanism intentionally not published here]
- The implementation is written to be constant-time and side-channel-aware. [FACT that the design goal is enforced; the method and any measurement are not published]
- HONEST LIMITATION, stated by design: ZAPLink today does NOT provide forward secrecy. The current seal is to a static recipient key, so an adversary who LATER compromises that key (a key compromise, not a quantum computer) could open datagrams captured earlier. Until a fresh-per-message key path is wired and gated, ZAPLink is positioned as a fast sealed-delivery transport, not a forward-secret session protocol. A roadmap to add per-message forward secrecy exists in the estate; its mechanics are not published here. [FACT that the limitation holds and is disclosed; INFERENCE on the roadmap]
Measured performance (public, non-revealing)
End-to-end medians, one lab host, same payload class, 2026-10-23. Source: transport_bench.json in the ZAPLink proof pack. These are relative lab measurements, not a scale or throughput claim.
| Transport | End-to-end median | Adds a PQC seal + signature? |
|---|---|---|
| SFTP / FTPS (one file) | 104.7 ms | No, classical transport, plain copy |
| ZAPLink (sealed + signed) | 122.6 ms | Yes, ML-KEM seal + ML-DSA signature |
| HTTPS / TLS, cold | 303.0 ms | No, classical TLS handshake |
| HTTPS / TLS, session resumed | 310.5 ms | No |
| SMTP + STARTTLS (one mail) | 735.9 ms | No |
- ZAPLink delivered a sealed, signed message about 2.5 times faster than a cold HTTPS/TLS exchange. [FACT, our bench]
- The cryptography is off the critical path: sealing a payload measured about 17.9 ms and reading it back about 7.5 ms, against a network round-trip of about 104.7 ms. The seal and signature are computed before the packet is sent, so ZAPLink lands close to the raw SFTP floor while carrying a post-quantum seal and signature that SFTP and TLS do not. [FACT, our bench]
Method: medians over repeated local trials on a single lab host, one payload size class. Raw measurements are in the proof pack and available on request.
Client FAQ
1. Is this real post-quantum cryptography or a wrapper around classical crypto? Real. The seal uses ML-KEM-1024 (FIPS 203) and the signature uses ML-DSA (FIPS 204), the NIST-standardized post-quantum algorithms, with AES-256-GCM for the symmetric seal.
2. Why is it faster than HTTPS if it does more cryptographic work? Because the slow part of TLS is the handshake negotiation, not the encryption. ZAPLink does the seal and signature before sending, so there is no handshake round-trip on the critical path. The cryptographic work itself measured a small fraction of the network round-trip.
3. Does it provide forward secrecy? Not today, and we tell you that directly. The current channel seals to a static recipient key, so a later compromise of that key could expose earlier captured traffic. A fresh-per-message path is on the roadmap. We will not put a post-quantum label on a property the channel does not yet have.
4. Do these numbers describe my network? No. They are relative measurements from one lab host on one payload class, meant to show the overhead of the PQC seal relative to familiar transports, not to predict your throughput or scale. We will share the method and the raw numbers on request.
5. Does it need SSH or an open inbound port? No. It is a mutually authenticated agent-to-agent channel that does not require an interactive SSH session. The internal transport and authority design are not part of this client proof.
6. Can we see the raw measurements and method? Yes. The proof pack (transport_bench.json and the measurement scripts) is available on request.
Qrypto Federal. DEMONSTRATION artifact; measured medians from one lab host, 2026-10-23; relative, not a scale claim. US English, ASCII-clean.
See it run