Privileged access with no vault the vendor can open.
CypherGuard splits every secret across your team's own devices and reconstructs it only inside a hardware-attested enclave. Every privileged action needs a quorum of your people to approve. We run the plumbing and can never read what you protect, and you can verify that for yourself.
Attestation has been verified end to end on real AWS Nitro hardware, with the enclave measurements pinned and a tampered enclave refused. In local development the enclave runs in a clearly labeled dev mode, and the dashboard says so.
The same verifier runs in Rust and in the browser, byte for byte. Clients refuse to talk to an enclave they cannot verify.
Everyone else holds the keys. We built a PAM where nobody has to.
Traditional privileged access managers keep a vault, and someone always holds the key to open it: an unseal token, a root credential, a cloud admin. Compromise that one thing and every secret is exposed. CypherGuard removes the single thing worth stealing.
| Question a security team asks | CypherGuard | Vault-style PAM | Classic enterprise PAM |
|---|---|---|---|
| Can the vendor read your secrets? | No, provably | Yes | Yes |
| Is there a master key or unseal token anywhere? | None | Yes | Yes |
| Is approval by quorum built into every action? | Yes | Policy only | Add-on |
| Can you verify the audit trail yourself? | Yes, in the browser | Log files | Log files |
| Is there a post-quantum path? | Yes, in progress | No | No |
Agentless on your targets, clientless for your operators, zero-custody for us.
Three parts, one trust boundary.
Secrets live only as shares on your devices and only as plaintext inside the attested enclave, for the instant it takes to use them. Everything in between sees ciphertext.
Member devices
Each device holds one Shamir share of the team key and its own signing key. A share alone reveals nothing.
Coordinator
Sequences requests, counts votes, stores public documents and sealed blobs. It is untrusted on purpose.
Nitro enclave
After a quorum approves, shares are combined here, the secret is used or a short-lived credential is minted, then it is destroyed. Clients verify its attestation first.
Threshold cryptography
Shamir secret sharing over a 448-bit field. Any T of N devices can authorize a use. Fewer than T learn nothing, mathematically.
Enforced attestation
Every client checks the enclave's signed measurements before trusting it. The check runs in Rust and in your browser, and a mock or tampered enclave is refused.
Verifiable audit
Every action is chained with SHA3 and can be re-verified in the browser. The enclave signs the chain head, so a compromised coordinator cannot rewrite history undetected.
Built for access nobody should hold alone.
Zero-custody lands first where a single held key is an unacceptable risk.
Managed service providers
Broker access into many client environments without ever holding a client's secret. Each team is cryptographically isolated, so one deployment serves every tenant.
Regulated and audited teams
Quorum approval and an audit chain you verify yourself give separation of duties and audit evidence by construction, not by policy or a log file.
Signing and certificate infrastructure
Run a certificate authority and a shared HSM with no signing key at rest. Mint certificates and sign releases under a team vote, keys used in the enclave and destroyed.
Break-glass production access
High-value production access that needs a live quorum, with one-time injected credentials and sessions that are recorded to the chain and can be terminated on the spot.
From a new laptop to a recorded, rotated session.
Everything here is built and runs today. The one part still moving to attestable hardware is the session gateway, noted honestly in the roadmap.
Start from the browser
Create a device in the browser (keys generated locally, wrapped by a passkey) and start a team with one seat link per teammate. No engineer, no key files.
Form a quorum
Teammates open the link, generate keys, and take a seat. Both sides compare a safety code, then the team forms T-of-N. A 2-of-3 team needs any two of three to approve.
Onboard a target
Register a Linux host, Windows server, or database with a guided wizard. Password targets install nothing; certificate targets need one line of SSH config.
Request access
An operator asks to connect. Each approver sees a readable card (who, which target, which access, how long) and approves on their own device.
Connect, zero-custody
On approval the enclave mints a short-lived certificate, or a stored password is checked out sealed to the gateway and injected there. A shell or full desktop opens in the browser.
Rotate, record, reclaim
Injected passwords rotate after check-in, so they are one-time. Sessions are signed to the audit chain, shown live, terminable, and auto-reclaimed if they die.
What happens when something goes wrong.
The point of the design is that a breach of any one part does not hand over your secrets. Here is the honest answer to each hard question.
1What if the web dashboard or admin panel is fully compromised?
The dashboard and the coordinator behind it are untrusted by design. They never hold a secret, a share, or a key. An attacker who owns them completely still cannot read a single protected credential, because the material to reconstruct one lives on your members' devices and is only ever combined inside the attested enclave.
They also cannot forge an approval. A vote carries real cryptographic share material and is signed by a member's device, and the enclave verifies both. They cannot quietly rewrite the audit trail either, because the enclave signs the chain head and any client can catch a mismatch.
The honest limit: the coordinator is the availability layer, so a compromise there is a denial-of-service risk. It is a blast-radius problem, not a disclosure of your secrets.
2What if an attacker steals one of our devices?
One device holds one share. In a T-of-N team, anything below T shares reveals nothing about the secret. That is a property of the mathematics, not a policy setting.
On top of that, device keys are encrypted at rest, in the browser under a passkey and in the CLI under a memory-hard passphrase, so a stolen device does not surrender a usable key. If a device is lost, you re-key: a new member set gets fresh shares and the old share is invalidated.
3Where is the single point of failure?
There is no single thing to steal. There is no master key, no root token, no unseal ceremony, no admin who can open the vault. Confidentiality is spread across a quorum of independent devices, and the only place a secret is ever whole is a hardware-attested enclave whose code is measured and pinned.
This is the core difference from a classic vault, where one credential or one operator can expose everything.
4What about a zero-day, or a compromised dependency?
No honest vendor claims immunity to zero-days. What we claim is a small blast radius. The most exposed and most attacked surface, the internet-facing coordinator and dashboard, is exactly the part that holds no secrets, so a zero-day there does not disclose your credentials.
The one component that does see plaintext is deliberately tiny and measured: the enclave. Its code is reproducibly built and its measurements are pinned, so a swapped or backdoored image fails attestation and every client refuses it. Reducing the trusted code to that minimum is the whole design.
5Is this ready for quantum computers?
CypherGuard is built for Q-Day, and post-quantum ready. The post-quantum primitives, ML-KEM-1024 for key encapsulation and ML-DSA-87 for signatures, are implemented in the codebase behind a feature flag. The live path today uses strong classical cryptography, X448 and Ed448, and the roadmap turns on hybrid classical-plus-post-quantum once byte-compatibility is proven across the enclave and the browser.
We say ready, and we do not say resistant. The architecture is designed so the upgrade is a swap of the combiner, not a redesign.
6Can we verify all of this ourselves?
Yes, and that is the point. You can read the enclave measurements in the attestation badge and compare them to the published reference. You can re-verify the entire audit chain in your own browser. The protocol and trust model are documented per feature, and the same verifier code runs in Rust and in the browser so there is nothing to take on faith.
In the live demo we show the green attestation on real hardware, and we show the same client refuse a tampered enclave.
Measured, not asserted.
Every number comes from a repeatable benchmark against the real protocol, not a slide.
319 automated tests
The full workspace suite passes, with clippy clean and the browser crypto proven byte-identical to the enclave on every build.
Continuous integration
Every change runs the tests, the quality gate, the web build, a Windows CLI build, a multi-step end-to-end smoke, and real-host SSH and RDP proofs.
Durable and recoverable
Writes are committed before a request is acknowledged. Pull the plug mid-approval and the vote resumes on restart with nothing lost.
Production-grade core, an honest roadmap.
Security teams trust candor more than a perfect scorecard. Here is what is solid today and what we are finishing next.
Production-grade today
- Threshold crypto core and the full approval engine
- Enforced attestation with measurements pinned, proven live on AWS Nitro
- Durable store that survives a crash mid-vote with zero loss
- Encrypted channel from coordinator to enclave, bound to the attestation
- The PAM surface: managed targets, brokered SSH and RDP, auto-injection, rotation, recording, live terminate
- Verifiable audit chain, signed by the enclave
In progress, next
- Approvals bound to signed intent so a card can never misdescribe a request
- Attested session gateway: in-browser SSH and RDP work today; hardware-attesting the gateway itself, so its badge goes green like the enclave's, is next
- Approval notifications to phones and chat, so the only wait is a human noticing
- Scale hardening for larger managed-service fleets
- Host-key and certificate pinning on first connect
- Compliance collateral: threat model and control mapping
What you are about to see.
A real team, a real quorum, and a real target. Watch a secret get used without any one party, including us, ever being able to read it.
- 01A brand-new team forms from the browser, with two teammates approving from their own phones.
- 02The enclave attestation is green on real AWS Nitro, with the measurements pinned.
- 03An operator requests access to a managed host. The quorum approves on separate devices.
- 04A live SSH session and an RDP desktop open, with the credential injected out of sight.
- 05The audit chain re-verifies in the browser, and a tampered enclave is refused on the spot.
- 06The password rotates after check-in, so what was used is already dead.
$ cypherguard connect prod-db requesting access to prod-db (ssh, cert) ... approval 1/2 bob approval 2/2 carol certificate issued in enclave, ttl 5m, key_id cypherguard:target:prod-db connected. no standing key, access recorded on the audit chain