Threat Model
This document describes what Qpher protects, what it does not, and where the trust boundaries lie. It is intended for security teams evaluating Qpher for production use.
What Qpher Protects
Primary Threat: Harvest Now, Decrypt Later (HNDL)
Nation-state adversaries and well-funded attackers are intercepting encrypted traffic today with the expectation that quantum computers will eventually break classical encryption (RSA, ECC). This attack pattern is known as Harvest Now, Decrypt Later (HNDL).
Qpher implements the NIST post-quantum standards and hybrid modes built on IETF drafts:
- ML-KEM-768 and ML-KEM-1024 (FIPS 203) for key encapsulation
- ML-DSA-65 and ML-DSA-87 (FIPS 204), and SLH-DSA (FIPS 205), for digital signatures
- X-Wing (X25519 + ML-KEM-768) and a composite ECDSA P-256 + ML-DSA-65 signature, the hybrid modes
ML-KEM-1024 and ML-DSA-87 are the parameter sets named in the NSA CNSA 2.0 suite. These algorithms are designed to resist attack by a quantum computer. Values that cross the network to or from Qpher also depend on the connection's key exchange — see Trust Boundary 3.
Data at Rest Protection
With client-side encryption, /kem/encapsulate gives you a one-time shared secret that you
use with AES-256-GCM in your own environment. The server-side /kem/encrypt does the same inside Qpher (ML-KEM
encapsulation, HKDF and AES-256-GCM) and returns the ciphertext. Either way you can store the ciphertext anywhere;
opening it again needs the matching private key, which is kept in Qpher's isolated key service.
Digital Signature Integrity
ML-DSA and SLH-DSA signatures made through Qpher are designed to resist forgery by a quantum computer. Use cases include document signing, software supply-chain integrity and tamper-evident records. Verifying through Qpher needs the signing key to be active or retired: once a key is archived, Qpher can no longer verify its signatures.
Key Lifecycle Security
Qpher manages the full lifecycle of PQC keys — generation, rotation, retirement, and archival (archival only in Qpher Console). Every key has an explicit version number. Encrypt and sign may omit key_version: Qpher uses the active key and returns its version. Decrypt, verify, encapsulate and key wrap always need it.
Trust Boundaries
Trust Boundary 1: Customer Environment
Your plaintext data stays in your environment. When using the KEM API, the SDK sends a KEM request to Qpher and receives a one-time shared secret. The SDK then uses this shared secret locally with AES-256-GCM to encrypt your data. Plaintext never leaves your environment in this mode.
The /kem/encrypt endpoint works differently. Server-side mode. Sent to Qpher over TLS, processed in memory,
never stored. Choose the mode that matches your trust requirements.
Trust Boundary 2: Qpher Platform
- Private keys are generated and used only inside the KMS-Orchestrator and are never exported
- No API endpoint can export or return private key material
- In the key service's storage, each private key is encrypted by a key held in Google Cloud KMS and referenced by handle, not by value
- Each customer gets a separate tenant, isolated at four layers: repository filtering, database constraints, request context and gateway enforcement.
- All key operations are recorded in a SHA-256 hash chain: each entry embeds the previous entry's hash, so altering or removing one entry invalidates every entry after it
- A daily job signs a checkpoint of each tenant's chain with a platform-held Dilithium3 key (anchors exist from August 2026 onward). A verified checkpoint detects rewriting of the chain by an actor with database write access but not the KMS signing identity
Trust Boundary 3: Transport Layer
- Connections to Qpher use TLS, terminated by Google Cloud in front of Cloud Run; TLS 1.3 is negotiated with clients that support it
api.qpher.ainegotiates the hybrid post-quantum key exchange X25519MLKEM768 with TLS clients that offer it; clients that do not offer it get a classical key exchange- Qpher does not provide its own TLS layer — transport security is delegated to the cloud provider
Values that cross this connection — your API key, your plaintext in server-side mode, the shared secret returned by
encapsulate and decapsulate, and the file key you send to key/wrap or get back from key/unwrap — are protected
in transit by TLS alone. Against an attacker who records traffic today, they are only as safe as the key exchange your
client negotiates, and a recorded shared secret or file key opens the document it protects.
What Qpher Does NOT Protect
The following items are explicitly outside Qpher's protection scope. Understanding these boundaries is essential for a complete security evaluation.
Transport Layer Attacks
Qpher encrypts documents and keys, not the connections your systems make; for data in transit, use a TLS stack with post-quantum key exchange.
That includes your connection to Qpher: see Trust Boundary 3.
Client-Side Security
Qpher does not protect your application code, your server environment, or your API key storage. Securing your API keys, managing environment variables, and hardening your runtime environment are your responsibility.
The shared secret returned by the KEM API exists in your application's memory. Its lifetime and secure erasure are governed by your runtime environment and coding practices.
Real-Time Communication Encryption
Qpher is optimized for data-at-rest encryption and digital signatures. It is not designed for real-time messaging encryption (e.g., end-to-end encrypted chat). If you need PQC protection for real-time communication, use a messaging protocol with post-quantum key agreement.
Availability Guarantees
Qpher follows a fail-closed design — if the platform is unavailable, cryptographic operations will fail rather than fall back to weaker algorithms. This is a deliberate security decision, but it means your application must handle temporary unavailability gracefully.
Verification and Auditability
Qpher provides mechanisms for you to verify the platform's security claims:
| Claim | How to Verify |
|---|---|
| Private keys are non-exportable | No API endpoint returns private key material. Verify by inspecting the API Reference. |
| Operations are recorded in an audit log | On every paid Qpher Console plan, the audit log API lists your organization's entries, and the audit-chain export returns them with the hash chain that links each entry to the one before it. See Audit Logging for what is recorded. |
| Individual audit entries have not been altered | Call the chain verification endpoint to re-derive every entry's hash. Altering or removing any entry invalidates every entry recorded after it. This detects modification of individual entries. |
| The chain has not been wholesale-recomputed since its last signed checkpoint | The same endpoint verifies Dilithium3-signed checkpoints (anchors) that a daily job creates over each tenant's chain (from August 2026 onward). A checkpoint mismatch detects rewriting by an actor with database write access but not the KMS signing identity — a DBA, a restored backup, SQL injection, or a compromised service account holding database credentials. It does not survive compromise of the KMS signing identity itself; the response reports any sequence ranges no verified checkpoint covers. |
| Tenant isolation | Each API key resolves to exactly one tenant. Cross-tenant requests return 403 or 404. |
| Fail-closed behavior | If the Policy Engine cannot be reached, API requests are denied with 503; an allowed decision from the last 10 seconds can still be reused. See Zero Trust. |
Comparing Qpher with a cloud KMS
Google Cloud KMS and AWS KMS ship post-quantum key operations. They give you primitives — key encapsulation and signing. Qpher gives you the hand-off: encrypt on your device, sign in your name, deliver to someone outside your organization, and prove it later.
See Qpher and other PQC options.
Frequently Asked Security Questions
How do I know you are not saving my keys?
Qpher is not zero-knowledge. Private keys are generated and used only inside an isolated key service and are never exported; on client-side paths (Vault, Organization send, .qpher) Qpher never sees the plaintext; the API's server-side mode receives plaintext over TLS, processes it in memory and does not store it. At rest they are encrypted with a Google Cloud KMS key.
What you can check or rely on:
- No API endpoint returns private key material. This is enforced at the code level.
- Only the KMS-Orchestrator's code loads private keys. In the key service's storage, each is encrypted by a key held in Google Cloud KMS and referenced by file handle, not by value.
- Shared secrets and file keys that pass through the key service are not stored.
- All key operations are recorded in a hash chain, so altering or removing any past entry invalidates every entry recorded after it. Since August 2026, a daily job additionally signs a checkpoint of each chain with a platform-held Dilithium3 key, so a wholesale rewrite by someone with database write access — but not the KMS signing identity — fails verification too.
- No SOC 2 audit has been completed.
What if TLS is broken by quantum computers?
At rest, what Qpher encrypts is wrapped with ML-KEM and AES-256-GCM, and what it signs carries an ML-DSA or SLH-DSA
signature, wherever you store it. What crosses the network to or from Qpher — your API key, your plaintext in
server-side mode, shared secrets and file keys — is protected by TLS, so against an attacker who records traffic today
it is only as safe as the connection's key exchange. api.qpher.ai negotiates the hybrid post-quantum key exchange
X25519MLKEM768 with clients that offer it; check that your HTTP client's TLS library does.
Next Steps
- Trust Model — What you are trusting Qpher with
- Security Architecture — Service diagram and auth pipeline
- Non-Exportable Keys — How private keys are protected
- Why Qpher? — when Qpher fits, and when it is not the right tool