Skip to main content

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.ai negotiates 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​

Not in Scope

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:

ClaimHow to Verify
Private keys are non-exportableNo API endpoint returns private key material. Verify by inspecting the API Reference.
Operations are recorded in an audit logOn 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 alteredCall 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 checkpointThe 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 isolationEach API key resolves to exactly one tenant. Cross-tenant requests return 403 or 404.
Fail-closed behaviorIf 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​