Post-quantum E2EE
you can ship today.
ML-KEM-768 + Double Ratchet behind a three-line API. Built with our first design partners in healthcare, fintech, and Web3. White-glove integration, direct line to the cryptographer — free during pilot.
// Before: readable by anyone with a quantum computer. // After: 3 lines. That's it. import { Stvor } from '@stvor/sdk'; const alice = await Stvor.connect({ userId: 'alice@example.com', appToken: 'stvor_live_xxx', pqc: true, // ML-KEM-768 hybrid X3DH }); await alice.send('bob@example.com', { text: 'Quantum-safe. Zero setup.' }); alice.onMessage(msg => console.log(msg.data)); // decrypted ✓ // ML-KEM-768 + Double Ratchet · 0 deps · NIST FIPS 203
Building STVOR at 19. Implemented ML-KEM-768 (NIST FIPS 203) from scratch in TypeScript — zero external crypto dependencies, only node:crypto and Web Crypto API. Verified against official NIST ACVTS test vectors. Previously: low-level systems work. STVOR is not an anonymous library — it has a name, a face, and a direct line to the person who wrote every line of the crypto core.
Your app is being
recorded today.
Adversaries harvest encrypted traffic now to decrypt it later — when quantum computers arrive. This is called "Store Now, Decrypt Later." It's happening to your users right now.
TLS is already obsolete
TLS and standard encryption will be broken by quantum computers. User messages, API tokens, and session keys — all exposed via "harvest now, decrypt later". Adding E2EE yourself takes months and requires expert cryptographers.
Wallet-native E2EE — pqc.stvor.xyz
Building on-chain? STVOR ships a sibling Web3 product: identity = wallet, no accounts, no API keys. Private DAO governance, OTC deal rooms, wallet-to-wallet DMs — all post-quantum from day one. Visit pqc.stvor.xyz →
Complex crypto.
Zero complexity.
STVOR packages military-grade post-quantum cryptography into an API that any developer can use. No cryptography degree needed.
Install & connect
One npm install. Connect with your wallet, API key, or any EIP-1193 provider. Works with MetaMask, TON, Safe, Coinbase — anything.
STVOR handles the crypto
Hybrid X3DH key exchange (ML-KEM-768 + P-256) happens automatically. Your shared secret is quantum-safe from the first message.
Send & receive
send() and onMessage(). That's the entire API. Double Ratchet ensures every message uses a fresh key.
One library.
Every stack.
Add E2EE to your app in 10 minutes
No cryptography knowledge required. STVOR gives you the same encryption used by Signal — with post-quantum protection Signal doesn't have yet.
- Node.js ≥ 18 — uses only built-in
node:crypto - Zero npm runtime dependencies — no WASM, no native modules
- Forward secrecy: each message uses a unique Double Ratchet key
- Identity derived from any user token — userId can be email, UUID, anything
import { Stvor } from '@stvor/sdk'; const alice = await Stvor.connect({ userId: 'alice@example.com', appToken: 'stvor_live_xxx', pqc: true, }); // Send quantum-safe message await alice.send('bob@example.com', { text: 'Hello!', }); // Receive — decrypted automatically alice.onMessage(msg => { console.log(msg.from, msg.data); });
Same SDK, native browser crypto
Full Double Ratchet runs in the browser via the platform's Web Crypto API — no WASM bundle, no shim. Keys persist across page refreshes in IndexedDB.
- Web Crypto API (no shims, no polyfills)
- Identity keys persisted in IndexedDB across tabs and refreshes
- Same
Stvor.connect()API as Node.js - 9 supported JS types — string, Date, Set, Map, Uint8Array, etc.
import { Stvor } from '@stvor/sdk/web'; const alice = await Stvor.connect({ userId: 'alice@example.com', appToken: 'stvor_live_xxx', pqc: true, }); // Original JS types are preserved end-to-end await alice.send('bob', { ts: new Date(), attachment: new Uint8Array(bytes), }); alice.onMessage(msg => { // msg.data.ts is a real Date instance });
First-class hooks & composables
The SDK ships React hooks and Vue composables out of the box — no wrapper libraries, no extra dependencies. Identity stays in IndexedDB; messages flow through reactive state.
useStvor()hook — connect, send, message stream- Vue 3 composables with the same surface area
- Optional
react/vuepeer deps — only loaded if you import them - SSR-safe: connection only initialises on the client
import { useStvor } from '@stvor/sdk/web'; export function Chat() { const { client, messages, send } = useStvor({ userId: 'alice@example.com', appToken: 'stvor_live_xxx', pqc: true, }); return ( <div> {messages.map(m => <p>{m.data.text}</p>)} </div> ); }
Every commit is public.
Every vector is verified.
Pure TypeScript on Node.js + Web Crypto in the browser. Zero runtime dependencies, zero native modules — every line of crypto is auditable in your editor.
What your CTO
actually cares about.
No cryptography degree needed to understand why this matters for your business.
A telemedicine platform sends consultation notes and diagnoses between doctors and patients. TLS encrypts the channel — but the server sees everything. One breach exposes every conversation ever stored. Quantum computers will crack today's TLS retroactively.
Messages are encrypted on the device before leaving. The server stores only ciphertext it cannot read. A breach leaks nothing. Quantum-safe from day one — no infrastructure changes.
Two institutions negotiate a $50M OTC trade over a chat platform. The platform operator, their cloud provider, and any nation-state with a wiretap order can read the terms. Leaking deal size and price before settlement moves the market.
Wallet address = identity. No accounts, no passwords, no KYC friction. Deal terms are E2EE — only the two counterparty wallets can ever read them. Forward secrecy means past deals stay safe even if keys are later compromised.
Your support platform stores every customer conversation in plaintext: API keys, account recovery details, internal screenshots. One leaked DB dump or one rogue employee = years of customer secrets exposed. TLS only protects the wire, not the storage.
Three lines turn the chat into E2EE. Your relay stores only ciphertext it cannot read. The customer's browser and the agent's app are the only two parties that can decrypt. SOC 2 / ISO 27001 evidence becomes trivial — the data never existed in plaintext on your servers.
Why join early?
We're onboarding the first 10 design partners. You get things that won't exist at v1.0.
Free during the entire pilot
No contracts, no invoices, no commitments. We integrate together, you ship quantum-safe E2EE, we get a real-world test case. Fair exchange.
Direct line to the cryptographer
Private Telegram/Slack channel with the person who wrote the crypto core. Not a support ticket queue — a direct conversation. Integration questions answered in hours, not days.
You shape the roadmap
ML-DSA signatures, group E2EE, React hooks, Python bindings — which of these matters to your stack? Design partners decide what gets built next and get early access to every new feature.
3 of 10 spots remaining
Healthcare, FinTech, Web3, AI — all verticals open. Takes 5 minutes to apply. We respond within 24 hours.
From library
to standard.
Full transparency. Design partners vote on priority and get early access to every phase.
Hybrid E2EE Core
- ML-KEM-768 + P-256 X3DH
- Double Ratchet · Sender Keys
- AES-256-GCM · HKDF-SHA256
- NIST ACVTS verified
- Sealed sender · TOFU
Production hardening
- Hosted relay v2 — multi-region
- Atomic state persistence
- 10 design partners onboard
- Full docs site
Quantum signatures
- ML-DSA-65 — NIST FIPS 204
- Quantum-safe identity signing
- External security audit
- Bigger NIST vector coverage
Cryptographic platform
- PQC-MLS group protocol
- Python bindings via Pyodide
- ZKP on lattices — PQC proofs
- Merkle key aggregation
NIST-verified.
Open source. Reproducible.
Every cryptographic primitive is tested against official NIST ACVTS test vectors. Pure TypeScript — every line of the crypto core is auditable in your editor. No WASM black box, no native modules, no transitive dependencies.
Try it now.
No install needed.
Real ML-KEM-768 + AES-256-GCM running in your browser via Web Crypto. Keys never leave your device.
Generate P-256 keypair
Click "Generate keys" to create a P-256 identity keypair in your browser.
Encrypt a message with AES-256-GCM
Sign & verify with ECDSA P-256
Sign the message above with your P-256 key and verify the signature.
Build the quantum-safe
future. With us.
We're onboarding the first 10 design partners. Free integration support, direct access to the cryptographer, and influence over the roadmap.