Key management professionals are used to being the people in the room who ask the “uncomfortable” security questions. Who has access to this key? Under what conditions can it be used? What happens if the environment requests it is compromised?
These questions have good answers in well-run PKI and KMS programs for conventional workloads. AI inference workloads, however, change how key release decisions are made.
Confidential Computing introduces a mechanism that closes that gap: attestation-gated secure key release. It is not a new concept in cryptography, but its application to AI workloads is relatively recent, and its implications for key management programs in organizations deploying AI on sensitive data are significant enough to warrant a dedicated look.
The Key Release Decision in Conventional KMS
In a conventional key management architecture, the key release decision is fundamentally identity-based. A workload or application authenticates to the KMS using credentials (a certificate, a service account token, an API key, a hardware-bound credential from an HSM), and if the credentials are valid and the access policy permits it, the key is released. The KMS verifies who is asking. It does not verify the state of the environment the requester is running in.
This works reasonably well for most enterprise applications because the threat is primarily about unauthorized access rather than compromised execution environments. If you trust the application and authenticate it correctly, releasing the key seems like the right call. That said, this approach has limits that become clearer when workloads grow in sensitivity and persistence.
What Does Attestation Add to the Release Decision?
Attestation-gated key release brings in a second dimension for making a release decision. Instead of asking only who’s requesting the key, it also asks in what state the entity requesting the key is, and you can cryptographically verify that state.
The verification method is remote attestation. Before the key management system releases a key to an AI inference workload, the hardware running that workload generates a signed attestation report.
The report captures the hardware identity of the processor, the firmware version running on it, the security configuration of the Trusted Execution Environment, and a cryptographic measurement of the software loaded into the enclave. That report is signed by a key embedded in the silicon that can’t be extracted or replicated by any software layer, regardless of privilege level.
The key management system verifies that report against expected values. It confirms that the hardware is genuine, that the firmware matches approved versions, and that the software measurement corresponds to the expected workload. Only after that verification succeeds does the key get released. And crucially, the key is released only into the verified TEE; it goes directly into hardware-isolated memory where neither the host OS nor any administrator can read it.
How failure works is just as important as the success case. If, for whatever reason, attestation fails (bad firmware, an unwanted change to the software, or an unexpected hardware profile), the key is simply not released. It doesn’t have a degraded mode where it is released, and you get a message telling you it was not the correct version. The conservative mode of not releasing is the default. It’s the environment's responsibility to prove its own security before secure materials are allowed into it.
So, Why is This Important Specifically to AI?
As a professional new to this aspect of key management, you may think your team already has strong controls over key access and auditing. So what is this attestation thing actually solving for that hasn’t already been solved?
The answer has to do with how AI inference workloads handle the data that keys protect, and why the exposure window is more important when considering a model that runs continuously across many requests, as opposed to an app that only needs a single file or record.
In most conventional applications, a key unlocks something, like a database field, a stored file, or a message. It then performs a discrete operation, and the decrypted material is either re-encrypted or discarded. The window of exposure is bounded and relatively short.
AI inference works a bit differently. When you launch an AI model, you’re putting something that took years to build and holds a lot of proprietary value out into the world. That model sits in GPU memory for inference, handling sensitive input data and spitting out results that can be just as sensitive. The model’s weights, the input data, and all the stuff happening in between all coexist in memory. And not just for a single moment. Sometimes, this lasts for a while, across lots of inference requests. So the risk isn’t just a one-time thing. It stretches across the whole time the model’s running in that environment.
This is why the state of the receiving environment matters so much at key release time for AI. Once the model is decrypted and running, the keys that protected it have done their job. What protects the model and the data it processes from that point forward is the hardware isolation of the TEE. If the environment that received the key wasn't what it claimed to be, there is no recovery. The model is already exposed. The data is already being processed in an untrusted environment.
Attestation-gated secure key release is what prevents that scenario. It ensures the environment earns the key before it receives it, not after.
The Operational Implications for Key Management Programs
For security and key management leads thinking about what this means for their programs, there are a few practical considerations worth working through.
Attestation verification is a new dependency in the key release workflow. Traditional KMS integrations handle authentication, authorization and audit. Attestation-gated release adds a verification step that requires the KMS to receive, parse and evaluate attestation reports from hardware it may not have previously had visibility into.
Fortanix Confidential AI (CCM + DSM) natively supports secure key release with composite attestation across Intel TDX and AMD SEV-SNP CPU TEEs and supported NVIDIA confidential computing GPUs.
Fortanix Confidential Computing Manager (CCM) orchestrates and verifies the combined CPU and GPU attestation evidence, while Fortanix Data Security Manager (DSM) integrates the resulting trust decision into its Secure Key Release workflow. This ensures that cryptographic keys are released only to workloads that satisfy the configured attestation policies, rather than relying on a separate, manually managed out-of-band verification process.
Policy definitions become much sharper. Traditional KMS policies answer who can access which keys and under what conditions. Attestation-gated policies go further, adding hardware and software layers to that question: this key only goes to a TEE running a specific firmware version, with a matching software measurement, on approved hardware.
That level of specificity takes more work to define and maintain, but it also gives key management programs a degree of control over execution environments that conventional policies just can't match.
The audit trail becomes very clear, too. Every time a key is released, the system automatically logs who requested it, when, and exactly where it went. It captures the hardware identity, firmware state, and software measurement of the TEE that received it.
Nothing leaves without a record. For those governed by HIPAA, PCI-DSS, GDPR, or even the EU AI Act's requirement for technical documentation, this makes a very strong case.
Failure is clean here, and that's rare. When an environment fails attestation, the key doesn't move, and the event logs exactly why. There’s no ambiguity.
For key management pros who've spent years building workarounds for edge cases and degraded modes, "attestation fails, key stays locked" is a surprisingly welcome change of pace.
The Part That Gets Overlooked
There is a reason secure key release tends to get less attention than TEEs and attestation in Confidential Computing discussions. TEEs are where the data lives. Attestation is the process people watch. Key release is sort of the “middle man” that makes both of them work securely, and it operates quietly when everything is functioning as designed.
But for key management professionals specifically, it’s the most consequential part of the architecture. The TEE provides a protected environment, and attestation verifies it. Secure key release is what ensures those two things are actually connected: that keys only enter environments that have earned them, and that the cryptographic guarantees of the entire system hold from the moment of release through the end of the inference operation.
Deciding whether to release a key in a confidential computing environment is essentially a pass/fail moment for your security posture, but it's a decision that deserves deliberate thought. Making it a core part of your key management program, rather than an afterthought, is the work that everything else depends on.

