On This Page
Every CISO has had this exchange. A board member, a product manager, a sales rep fielding a prospect’s security questionnaire: someone asks whether the data is encrypted, and the answer is yes. Somewhere in the risk register, a control is marked as implemented. The conversation moves on. What does not get asked, and what the CISO usually knows is the harder question, is what exactly that encryption protects against, and for which workloads it falls short. The gap between the first question and the second is where most data confidentiality strategies live, and it is the subject of this article.
Why encryption is not always enough
Conversations about cloud data security usually bring up encryption early. Encryption in transit, encryption at rest, key management. These building blocks are now standard, and for good reason.
But for a CISO, the real question is not “is the data encrypted?” The question is: what are we protecting, from whom, and at what point in its lifecycle?
In other words: what is the actual threat model?
It is through this lens that the cryptographic building blocks covered in the previous articles of this series start to make sense as governance choices rather than as purely technical options. Encryption in transit, encryption at rest, end-to-end encryption: each of these mechanisms is valid in its own right, but none of them defines a trust architecture on its own. They are the tools with which an architecture is built, not the architecture itself. Confidential computing, which protects data during processing using hardware-enforced enclaves, is another such mechanism, examined in detail in its own article.
Positioning these mechanisms correctly is not primarily a technical exercise. It is a governance exercise.
Mechanisms and their protection scopes
The mechanics of encryption at rest and end-to-end encryption have been covered in detail in previous articles. The goal here is not to revisit them, but to position them from a risk governance perspective.
Encryption at rest: protecting the infrastructure layer
Encryption at rest protects data against threats that sit below the application layer: stolen or physically accessed disks, improperly decommissioned hardware. This is essential protection, but its scope is well defined. As soon as data is processed by an application, it exists in plaintext within the provider’s environment.
For a CISO, this is a baseline safeguard. Necessary, but not sufficient for more advanced threat scenarios. Configuring it well (via BYOK, HYOK, or a well-scoped KMS) strengthens operational control over the keys, but it does not change what the provider can technically access during normal operations.
End-to-end encryption: removing the provider from the threat model
End-to-end encryption fundamentally changes the posture. Data is never accessible in plaintext within the provider’s infrastructure. This directly addresses scenarios that encryption at rest cannot cover:
- legal requests directed at the provider
- control plane compromise
- insider threats within the provider
But this comes with a structural constraint: the provider cannot process the data in plaintext. This significantly limits use cases, particularly when analytics, server-side search, or AI workloads are involved.
Endpoint compromise has always been a risk, but under E2EE it becomes the main one. By removing the provider from the path, the clients become the highest-value entry point left. A compromised client device defeats end-to-end encryption regardless of how well the rest of the architecture is designed. This is not a flaw of E2EE, it is a consequence of where it places the trust boundary.
What about processing?
Between these two models sits a question that neither fully answers: what about data while it is being processed? Server-side processing is not a gap in E2EE, it is a different problem. If the server needs to operate on the content, the cryptographic architecture has to provide plaintext at that specific point, by design. Confidential computing, based on trusted execution environments, is one current answer: it allows processing to happen inside a hardware-isolated boundary that the provider cannot inspect. A dedicated article covers it. For this article, the point is narrower: a governance framework that does not acknowledge this design choice is incomplete.
The CISO perspective: thinking in risk coverage
For a CISO, these mechanisms are not competing solutions. They should be understood as complementary tools, each addressing a specific threat perimeter.
A useful way to frame this is:
| Model | Protects against | Does not protect against |
|---|---|---|
| Encryption at rest | Physical access, improperly decommissioned hardware | Provider access, plaintext processing |
| End-to-end encryption | Provider access, legal compulsion, control plane compromise | Metadata leakage, endpoint compromise |
| Confidential computing | Runtime access, OS/hypervisor compromise | Hardware supply chain, application-level leakage |
This highlights a key point: none of these models provides complete coverage. Data confidentiality governance is about arbitrating these trade-offs with eyes open, not about choosing the most secure-sounding label.
“Is the provider in the threat model?” is not a yes-or-no question
The most consequential governance decision, and the one most often simplified, is how the provider itself fits into the threat model. Either the provider is “trusted” and therefore excluded, or the provider is “not trusted” and therefore E2EE is required. This binary framing is convenient, and it is wrong.
Including the provider in the threat model covers a spectrum of sub-risks that do not necessarily go together:
Extraterritorial legal compulsion. A US-based provider, regardless of where the data is physically stored, is subject to the CLOUD Act. A European provider may be subject to other national frameworks. The question is not whether the provider is ethical, it is which jurisdictions can compel them to produce data, and under what process.
Control plane compromise. A breach at the provider’s administrative layer is categorically different from a breach at the storage backend, because it potentially yields keys, not just ciphertext. This risk is low-probability but high-impact.
Insider access within the provider. Not necessarily malicious. Misconfigured access policies, compromised employee credentials, or routine operational tasks that grant broader access than intended. The provider’s own security posture matters here, and it varies across providers and across services within the same provider.
Evolution of the provider’s offering. The service contracted with three years ago may process data differently today. New AI features, new integrations, new sub-processors. Each of these can quietly change what the provider sees without the customer noticing.
Corporate changes. Acquisitions, changes in ownership, changes in the sub-processor chain. A provider acquired by a company headquartered in a different jurisdiction is, from a threat model perspective, not the same provider.
A CISO who treats all of this as a single binary cannot make consistent decisions across workloads. For a public marketing site, most of these sub-risks are irrelevant. For a legal hold repository, several are central. The right posture is not the same, and the difference is not captured by a single tag.
Why data classification matrices are not enough
Most organizations have a data classification scheme: public, internal, confidential, restricted. These schemes are useful. They are also insufficient on their own.
Classification tells you how sensitive a piece of data is, but not what its threat model is. Two datasets classified “confidential” can have radically different threat profiles. A commercial contract and an internal investigation file may both be “confidential”, but the risk that a provider administrator reads the contract is operationally different from the risk that the same administrator reads the investigation file. The difference has nothing to do with sensitivity, and everything to do with who might want access and why.
Classification answers the question “how bad would it be if this leaked?” Threat modeling answers “who realistically might cause that leak, and through what mechanism?” These are different questions, and collapsing them into one produces controls that are either over-engineered for the actual threat or comfortably aligned with compliance while missing the real risk.
Governance that relies entirely on classification tends to produce one of two failure modes. Either all “confidential” data gets the strongest possible controls, which is expensive and often operationally painful, or all “confidential” data gets baseline controls, which leaves the subset with genuinely hostile threat models under-protected. Neither outcome reflects the actual risk landscape.
The unit of analysis has to be the workload, not the classification tier.
Governing, not deciding once
If the unit of analysis is the workload, and the threat model is not a binary, then governance cannot be a one-time decision. It has to be a discipline with at least four active components.
Document the threat model, not just the control. The risk register should say more than “data encrypted at rest with CMK”. It should state, for each workload, where plaintext exists in the lifecycle, who has access at each of those points, and which sub-risks on the provider spectrum are considered in scope. This produces something a control matrix cannot: a statement that can be challenged, revised, and audited against the actual architecture.
Make the non-coverage explicit. Every control has gaps. Encryption at rest does not protect against provider access during processing. E2EE does not prevent metadata leakage. Confidential computing does not remove trust in the hardware supply chain. A governance document that lists what each control protects against, without naming what it does not, will be read as a guarantee rather than as an architecture decision. Naming the gaps is the difference between a defensible position and a comforting one.
Plan for reassessment. The threat model is not static. A workload’s exposure changes when the provider acquires a new sub-processor, when a new jurisdiction enters the supply chain, when an AI feature is enabled on a previously silent service, when the organization itself enters a new market or acquires a subsidiary in a different regulatory environment. The governance process needs explicit triggers that require revisiting the threat model, not an annual review that rubber-stamps the previous year’s assessment.
Articulate the roles. Who decides the threat model for a given workload? Who documents it? Who has standing to challenge it? Who is responsible for detecting the events that should trigger reassessment? These responsibilities are typically distributed across the CISO, the DPO, enterprise architecture, and the business owner of the workload. When they are not explicitly assigned, the default outcome is that nobody owns the reassessment, and the threat model silently ages out of relevance.
None of these four are glamorous. They do not produce a diagram to show a board. They produce a process that, when it works, makes the board’s question (“are we protected?”) answerable with something more useful than “yes, we encrypt everything.”
The illusion of “everything is encrypted”
A common misconception is that “everything is encrypted” means “everything is protected.” It does not.
Encryption is a mechanism, not a guarantee. Its value depends entirely on the context in which it is applied. Encryption at rest protects storage. End-to-end encryption protects against the provider. Confidential computing reduces exposure during processing. None of them replaces a clear understanding of the threat model, and none of them, used in isolation, covers the full lifecycle of the data.
The value of saying this explicitly, in governance terms, is that it forces the distinction between a control being present and a risk being addressed. A control that is present but misaligned with the threat model is a compliance artifact, not a security outcome.
Conclusion
Encryption is not a checkbox. It is a set of tools that must be positioned correctly within a security architecture, and that positioning is a governance decision before it is a technical one. The technical implementation that follows has its own pitfalls, which the earlier articles in this series examined in detail.
For a CISO, the goal is not to adopt the “most secure” solution in absolute terms, but to build consistency between risks, use cases, and controls. Encryption at rest, end-to-end encryption, and confidential computing are not alternatives. They are partial answers to different problems, and a mature governance process recognizes which problem each one actually solves for a given workload.
The fundamental question remains: who should be able to access data in plaintext, and at no point beyond what is strictly necessary? Every data confidentiality strategy worth defending is built around that question. The encryption choices follow from it, not the other way around.