CypherGuard
Zero-custody privileged access management

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.

Enclave attestation, verified in your browser
Attested (AWS Nitro)
Signature and X.509 chainvalid
PCR03f9d1a7c8b02e5f4a1c6d9e2b7f0a3c5...
PCR1 and PCR2pinned, match
Mock documentrefused

The same verifier runs in Rust and in the browser, byte for byte. Clients refuse to talk to an enclave they cannot verify.

Hardware-attested enclave Zero-custody by design T-of-N quorum Tamper-evident audit Built for Q-Day
The shift

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 asksCypherGuardVault-style PAMClassic enterprise PAM
Can the vendor read your secrets?No, provablyYesYes
Is there a master key or unseal token anywhere?NoneYesYes
Is approval by quorum built into every action?YesPolicy onlyAdd-on
Can you verify the audit trail yourself?Yes, in the browserLog filesLog files
Is there a post-quantum path?Yes, in progressNoNo

Agentless on your targets, clientless for your operators, zero-custody for us.

How it works

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.

Your people

Member devices

Each device holds one Shamir share of the team key and its own signing key. A share alone reveals nothing.

Ed448X4481 share = 1 vote
Holds shares, never the whole secret
We host this

Coordinator

Sequences requests, counts votes, stores public documents and sealed blobs. It is untrusted on purpose.

Postgressealed blobs only
Sees only ciphertext, holds no key
The only trusted code

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.

PCR0-2 pinnedreconstruct, then zeroize
Reconstructs, then destroys, inside a measured TCB
Reconstruction happens only in the attested enclave The vendor-hosted coordinator never holds a secret or a key Every step is written to a tamper-evident audit chain

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.

Where it fits

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.

The journey, end to end

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.

1

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.

2

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.

3

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.

4

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.

5

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.

6

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.

The questions a security buyer asks first

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.

Proof, not adjectives

Measured, not asserted.

Every number comes from a repeatable benchmark against the real protocol, not a slide.

~11 ms
System time to check out a secret after a quorum approves
~86 ms
Threshold-approved SSH certificate issued and connected to a real host
~2.6 s
RDP desktop rendered in the browser through the attested gateway
< 1 s
Coordinator killed mid-vote, restarted, with zero loss

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.

Where we are, plainly

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 the live demo

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.

  1. 01A brand-new team forms from the browser, with two teammates approving from their own phones.
  2. 02The enclave attestation is green on real AWS Nitro, with the measurements pinned.
  3. 03An operator requests access to a managed host. The quorum approves on separate devices.
  4. 04A live SSH session and an RDP desktop open, with the credential injected out of sight.
  5. 05The audit chain re-verifies in the browser, and a tampered enclave is refused on the spot.
  6. 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