Confidential computing · x/enclave + x/encryption

Trusted processing: the lock and the key

VirtEngine's most sensitive work — scoring identity evidence, and running workloads whose data must not touch the operator — happens inside hardware-sealed enclaves. The chain verifies what is running before any byte is released to it, and the keys that open the data are forged in the hardware and never exist outside it.

A data-centre aisle: racks of servers receding into the distance.
A provider you can see. Memory they cannot read.

The whole journey

One scope, start to finish

An identity scope is sealed on your device, opaque everywhere in between, opened only inside a vault whose key was forged in the silicon, and destroyed once the answer exists. What the network keeps is evidence that the right steps happened — attestation records, envelope references, and results.

Hardware, not policy

What a trusted processing unit is

A trusted processing unit is a vault built out of the computer's own hardware. The technical names are trusted execution environments and confidential virtual machines — AMD SEV-SNP, Intel SGX and AWS Nitro are the three the system supports. Inside one, the processor itself encrypts the running memory, so even the machine's owner, looking at their own hardware, sees only ciphertext.

Ordinary servers have doors: an administrator account, a debug console, a memory dump. A trusted processing unit is designed with no doors at all — no operator login, no console, no way to read memory from outside. That is not a policy someone promises to follow; it is how the silicon works.

AMD SEV-SNP

Confidential VMs

Memory is encrypted by the processor itself, with integrity protection and a hardware-rooted attestation report — the confidential-VM path the identity scoring network runs on.

Intel SGX

Measured enclaves

Sealed regions inside a processor where code runs as a measured artifact, with attestation evidence bound to the manufacturer's certificate chain.

AWS Nitro

Hardware-isolated VMs

Enclaves on the Nitro platform — isolated execution with a signed attestation document that names the exact image and configuration running.

Attestation

The gate: attestation, checked on-chain

Before encrypted evidence is released to a vault, the vault must prove what it is. It produces an attestation — a signed statement from the hardware manufacturer's own certificate chain that says, in effect: "I am genuine sealed hardware, and I am running exactly this code, with this measurement."

The VirtEngine chain verifies that attestation on-chain, in its x/enclave module, checking the signature and comparing the code's measurement — a cryptographic fingerprint of every byte the enclave will run — against the approved record. If a single byte of code were different, the measurement would not match and no data would be released to it. Because the check is on-chain, it is public: anyone can confirm which enclave measurements the network accepts.

What attestation does and does not prove

Attestation proves the vault is genuine hardware running exactly the approved code — nothing more. The rest of the protection comes from what that approved code does: verify, report a result, destroy the evidence. Both halves are open source, so both halves can be inspected.

Key custody

The key: forged inside the hardware

The key that decrypts a scope never exists outside the enclave. It is derived inside the hardware, from the hardware's own secrets, and sealed so it can only ever be used by that exact enclave running that exact code — hardware-based key derivation with vTPM sealing, in the technical terms.

This is why "no one can open it" is a design fact rather than a promise: there is no key to hand over. Not to an operator with root access, not to the provider hosting the machine, not to the foundation that stewards the protocol, not in response to a demand. A key that never leaves the silicon cannot be copied, stolen, or surrendered.

Data lifecycle

What happens to evidence, stage by stage

The same journey as a lifecycle. Raw evidence exists inside the enclave only for the moments scoring takes — then it is destroyed, and only the result remains.

  1. Stage 01

    Captured

    Documents, a selfie with active liveness, and biometric hardware attestation are read on the handset. Raw evidence never leaves the device unencrypted.

  2. Stage 02

    Sealed

    Scopes are sealed to validator recipients with x/encryption envelopes. The chain stores references and key fingerprints — never plaintext.

  3. Stage 03

    Gated

    The enclave presents its measurement; x/enclave verifies it on-chain before any envelope is released. No proof, no data.

  4. Stage 04

    Processed

    The scoring service and its machine-learning models run as measured code inside the confidential VM — keys derived and sealed in hardware, memory encrypted by the CPU.

  5. Stage 05

    Destroyed

    Working copies exist only while scoring runs. When it ends, the enclave retains nothing; envelope expiry and revocation govern anything retained beyond it.

  6. Stage 06

    Results only

    A trust score and pass/fail outcome are committed to chain state by consensus. The evidence behind them is not.

Retention and destruction for the identity programme are published commitments, with figures attached — the Biometric Data Addendum's schedule is set out in full at identity.org.au/privacy/trusted-processing.

Confidential compute

The same machinery answers a marketplace question

How does a tenant know a provider's confidential-compute claim is real? The enclave modules turn confidentiality into a verifiable, pricable attribute.

Attested enclave capability is recorded in x/enclave, and orders can require it as a placement constraint — so unverified capacity never even matches. Workload secrets are sealed with x/encryption envelopes and released only after attestation verifies. The sequence is proof first, secrets second, and it is enforced by protocol machinery rather than provider goodwill.

x/enclave

Verifiable capability

Enclave measurements are recorded and checked on-chain, so confidential compute becomes an attribute that can be priced, filtered, and required in placement constraints.

x/encryption

Proof first, secrets second

Workload secrets are sealed to specific recipients and released only into an enclave whose attestation has verified — enforced by protocol machinery, not provider goodwill.

x/cert

Authenticated transport

Tenant clients and provider daemons authenticate each other with chain-anchored TLS certificates before any manifest or secret flows.

x/audit

Inspectable operation

Providers can carry auditor-signed attributes, so confidentiality claims stand alongside an audit trail rather than replacing it.

Visibility

Who can see what

The chain is a coordination and audit layer, not a data lake. Outside your device and an attested enclave, confidential material exists only as ciphertext.

For each category of data, who can read it — you, the counterparty, providers and operators, the foundation, or the chain
Data You Counterparty Providers & operators Foundation The chain
Raw documents & biometrics Only on your device Never Never Never Ciphertext references only
Envelope keys Held in your device's hardware Never Never Never Key fingerprints only
Trust score & tier In full Only what you consent to, per request Results within the consented scope Public results only Committed by consensus
Workload secrets Sealed to attested enclaves Never Never — memory is CPU-encrypted Never Ciphertext references only
Attestation records Produced by your device and the hardware Verifiable by anyone Recorded and checked on-chain Public Public

"Never" in this table is architectural: raw evidence is ciphertext everywhere outside your device and the attested vault, and the vault has no door.

Primary sources

Verification you can check

Every claim on this page maps to something inspectable in the repository or the documentation.

The honest limits

No security design is beyond all conceivable failure, and we do not claim this one is. What is claimed — checkably — is the design: attestation verified before data moves, keys sealed in hardware, no operator access path, and destruction commitments with dates attached. The network is not live; this page describes the protocol design.

Related

Continue from here