Isolation Is Not Confidentiality: Security Boundaries of Geometric Access Control in RAG
summary
The gist
Retrieval-Augmented Generation (RAG) systems increasingly rely on vector databases containing documents governed by different access-control policies Recent search-preserving geometric approaches…
In short
The study explores using geometric transformations to enforce access control in Retrieval-Augmented Generation (RAG) systems by creating 'protected representations.' While these methods successfully ensure policy isolation—preventing unauthorized retrieval—they fail to guarantee representation confidentiality or resistance against query forgery. The research shows that policy isolation is distinct from other security properties.
Key concepts
- Protected Representation
- This is the transformed embedding stored in the vector database. It is created by applying a secret, policy-specific geometric transformation to the original document embedding. This process structures the embedding space so that similarity search works correctly for authorized policies while hiding information from unauthorized ones.
- Policy Isolation
- This refers to successfully separating data belonging to different access policies within the vector database. Geometric transformations achieve this by structuring the embedding space such that embeddings from one policy cannot be easily retrieved or compared against embeddings from another policy, even if they are similar in a general sense.
- Representation Confidentiality
- This security objective means preventing an unauthorized user from recovering the original document embedding from its protected version. The paper finds that simply achieving isolation does not guarantee this; aligned pairs of original and protected embeddings allow a curious user to recover the original embedding at a manageable cost.
- Query Forgery Resistance
- This measures the system's ability to stop an adversary from constructing a search query that is accepted by an unauthorized policy. The study indicates that even with secret per-policy transformations, users can forge compatible queries at a dimension-dependent cost, meaning isolation alone does not prevent this attack.
Terminology used across episodes
This episode discusses
- Isolation Is Not Confidentiality: Security Boundaries of Geometric Access Control in RAG · Paper Radio
- Transform Before You Query: A Privacy-Preserving Approach for Vector Retrieval with Embedding Space Alignment
- SHARD: cell-keyed residual splitting for alignment-resistant private dense retrieval
- HONEYBEE: Efficient Role-based Access Control for Vector Databases via Dynamic Partitioning[Technical Report]
- ARBITER: AI-Driven Filtering for Role-Based Access Control
- Securing the Agent: Vendor-Neutral, Multitenant Enterprise Retrieval and Tool Use
- Privacy-Aware RAG: Secure and Isolated Knowledge Retrieval
- Provably Secure Retrieval-Augmented Generation
- SoK: Privacy Risks and Mitigations in Retrieval-Augmented Generation Systems
The paper
Isolation Is Not Confidentiality: Security Boundaries of Geometric Access Control in RAG · Read on arXiv
Steve Nouyep, Maxime Puys, Sébastien Salva
Université Clermont Auvergne · CNRS · Clermont Auvergne INP · LIMOS
Retrieval-Augmented Generation (RAG) systems increasingly rely on vector databases containing documents governed by different access-control policies. Recent search-preserving geometric approaches enforce such access control by structuring the embedding space so that transformed embeddings, which we call protected representations, remain retrievable without exposing information across policy boundaries. We provide a unified security analysis of this paradigm, covering policy isolation, representation confidentiality, query forgery resistance, and policy-membership hiding. We consider both a curious cloud service provider observing the protected representations stored in the vector database and a curious user holding aligned pairs of original embeddings and protected representations. Evaluating the available implementations of the works proposing these geometric transformation mechanisms across three encoders, we find that geometric transformations preserve retrieval utility and provide strong policy isolation, but do not provide the other security properties. A curious user can recover the original embeddings from a few hundred pairs and forge policy-compatible queries at a higher cost that grows with encoder dimension for secret per-policy transformations. Moreover, policy-dependent geometry can leak policy membership even when unauthorized retrieval is prevented. These results show that policy isolation, confidentiality, forgery resistance, and membership hiding are distinct security objectives.
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: We're looking at the paper: "Isolation Is Not Confidentiality".
Elias: Here's the gist of the paper. Retrieval-Augmented Generation (RAG) systems increasingly rely on vector databases containing documents governed by different access-control policies Recent search-preserving geometric approaches enforce such access control by structuring the embedding space so that transformed embeddings, which we call protected representations, remain retrievable without exposing information across policy boundaries.
Nadia: Core Problem and Proposed Solution The mismatch between embedding similarity search and authorization enforcement is a key issue in enterprise RAG deployments Existing methods address this using metadata-based filtering, policy-specific indexes, or cryptographic protection.
Elias: A different approach involves encoding authorization directly into embeddings through geometric transformations that preserve similarity, referred to as search-preserving geometric access control.
Nadia: In this paradigm, each policy is associated with a secret transformation of the embedding space, and the transformed embedding, called the protected representation, is what the vector database stores.
Title and authors: Nadia: So we're looking at this paper called "Isolation Is Not Confidentiality: Security Boundaries of Geometric Access Control in RAG". It basically says that these geometric methods, which transform embeddings into protected representations, are good at keeping things isolated between different access policies.
Elias: Right, they use secret transformations for each policy to structure the embedding space so that even if someone is looking at the protected representations, they can't easily see information about other policies. It sets up a system where you search for similar documents but only find the ones authorized for your policy.
Priya: But isolation isn't everything, right? The paper lays out four security goals: isolation, confidentiality of the data itself, resistance to forging queries, and hiding membership in a policy. It's important to see them as separate things that don't always go together.
Nadia: Exactly. They look at how hard it is for someone to recover the original embedding from a few hundred aligned pairs of original and protected representations, which is one way they check for representation confidentiality.
Elias: And they also check if someone can construct a query that works under an unauthorized policy, which is query forgery resistance. They found that these two things aren't necessarily linked in how these transformations work.
Priya: Plus, the paper points out a problem where this geometric separation can actually leak information about which policy a document belongs to, even if you've successfully stopped someone from retrieving unauthorized documents.
Nadia: That’s the big takeaway here: isolation is good for keeping things separate during retrieval, but it doesn't automatically mean you have representation confidentiality or forgery resistance.
Elias: And they show that the cost for a curious user to recover the original embedding or forge a query increases depending on how large the embedding dimension is, especially when those policy transformations are kept secret per policy.
Priya: That makes sense because it suggests that you can have strong isolation, but if you increase complexity by making those transformations more intricate, you introduce new vulnerabilities related to cost and hidden information.
Nadia: So what they’re suggesting is that we shouldn't just focus on isolation when building these RAG systems; we need to test for all these distinct security objectives separately.
Elias: And they found that the naive approach without any geometric transformation fails at isolation, so this method definitely provides a measurable level of separation, but it’s not perfect across all those fronts.
Priya: What this means practically is that if you build a system relying only on isolation, you still need other checks for data privacy and query security because the geometry alone doesn't guarantee them.
Nadia: We have to be careful about what we claim when we use these geometric methods; they provide a specific kind of control, but that control has its own boundaries defined by these measurements.
Title and authors: Elias: And looking at the dimension scaling, they noted that for some mechanisms, like the key-parametrized dimension augmentation, the cost for forgery resistance keeps climbing as you go from a dimension of three hundred eighty four to one thousand twenty-four.
Priya: That's a concrete number showing that increasing the complexity of the transformation directly increases how much effort it takes an attacker to build something malicious.
Nadia: But for others, like their key-parametrized augmentation, the cost stays around two hundred to three hundred pairs no matter if you go from three hundred eighty four up to one thousand twenty-four. That’s a bit of a confusing difference in the experimental results.
Elias: That difference comes down to how the transformation is structured; for instance, some mechanisms have a rotation that gets shared across all policies, which keeps that cost stable regardless of the dimension increase.
Priya: So, it seems like you can have different trade-offs depending on whether you’re looking at a rotation-based method or something more complex that changes based on the policy key.
Nadia: And we also have to remember that even when retrieval is blocked, this policy-dependent geometry can still reveal which policy a representation belongs to through some kind of clustering.
Elias: That points to membership hiding not being achieved just by having the separation in the embedding space; you need extra work there too.
Priya: So, if we’re building a system, isolation is one step, but we still need to address those other three objectives—confidentiality, forgery resistance, and membership hiding—on top of that geometric structure.
Nadia: That’s the main point of this paper: search-preserving geometric access control gives you strong isolation in RAG systems without giving you automatic protection against reconstruction or forging queries.
Elias: It’s a clear boundary we need to respect when designing these systems; it’s not an all-encompassing security fix on its own.
Priya: It suggests that the focus should be on understanding which of those four properties are most critical for your specific use case before you build something on this foundation.
Nadia: Right, so we’ve seen how these geometric transformations work and where their limits lie regarding what they can and cannot protect in a RAG pipeline.
Elias: And for the next step, we see that query authorization should probably happen before the request even gets to the vector database, relying on authentication instead of just hoping the embedding transformation holds up everything.
Priya: Exactly. Limiting how much data an attacker can observe, like restricting those aligned pairs they use for attacks, might make those reconstruction and forgery costs much harder to achieve in practice.
Nadia: So we’re leaving this paper with a clear map: geometric access control handles isolation well, but you still have to build in other layers for true security.
Elias: It’s a cautionary note that the math shows us, and it’s helpful for anyone designing these kinds of systems to know what the costs look like as they scale up.
Priya: A good reminder that isolation is not a magic shield; it's just one piece of the puzzle in securing your data pipeline.
The paper's summary: Nadia: So, to wrap up this part of the discussion, we're looking at what these authors actually concluded about their geometric access control system in RAG. They found that while this method is really good at keeping different policies separate—that isolation—it doesn't automatically mean you have protection against other attacks.
Elias: Right, they treat things like data confidentiality, query forgery resistance, and hiding membership as totally different goals. It’s not like if you achieve one of those things with the geometric setup, you automatically get all the others.
Priya: That’s the main takeaway for us—that isolation alone isn't enough to guarantee true security in an AI system. They showed that even when they stop unauthorized retrieval, this policy-dependent geometry can still leak information about which policy a document belongs to through some kind of clustering.
Nadia: It sounds like the paper is saying that we can have strong separation between policies during the search phase, but we still have to build on top of that for real data privacy and query security.
Elias: And they did show that if you want to recover the original embedding from a few hundred aligned pairs of original and protected representations, it's actually quite possible for a curious user. It depends on the dimension of the embedding space, though.
Priya: That's interesting because it means there’s a trade-off: you get isolation, but if you increase the complexity or dimension of the math used to protect things, you might be making recovery easier for an attacker.
Nadia: And when we looked at how much it costs to forge a query that works under an unauthorized policy, that cost actually goes up as the embedding dimension grows for those secret per-policy transformations.
Elias: But they noted that some specific geometric mechanisms, like their key-parametrized augmentation, keep the cost for forgery resistance pretty stable between a low dimension and a higher one. That suggests you can find different trade-offs depending on how the transformation is structured.
Priya: So, if you’re building something now, this paper tells you that isolation is just one piece of the puzzle; you still need to design layers specifically for reconstruction resistance and membership hiding.
Nadia: Exactly. The system they built provides measured isolation, but it doesn't solve the entire security problem on its own.
Elias: It points toward a future where maybe query authorization should happen before the request even hits the vector database, relying on some kind of authentication instead of just hoping this geometric transformation does everything.
Priya: And honestly, limiting how much data an attacker can observe, like restricting those aligned pairs they use for attacks in those experiments, might make those reconstruction and forgery costs way harder to achieve in practice.
Nadia: It’s a caution that the math shows us: geometric access control is a powerful tool for separation, but you still have to build in other checks for true security.
Elias: Yeah, it’s a good reminder that isolation isn't a magic shield; it's just one piece of the puzzle in securing your data pipeline.
The paper's improvements: Tom: So, we're now looking at what the authors suggest as improvements for their geometric access control method in RAG. They realize that just having isolation isn't enough to cover all the security bases they laid out earlier.
Nadia: Right, they say you need to move beyond just separating the embeddings and start using something like bounded nonlinearity or adding some noise during the transformation process itself. This would limit how easily an attacker can reconstruct the original embedding from those aligned pairs of data.
Elias: That makes sense because if there's a bounded nonlinearity, it limits the fidelity of that reconstruction attempt, keeping it within a manageable cost budget for an attacker. They want to keep that cost low enough so it doesn't become too much of a headache for them.
Priya: I see how that connects back to representation confidentiality, right? By adding noise or nonlinearity, they’re trying to make sure that the protected representation doesn't look *too* similar to the original embedding in a way that lets someone reverse it easily.
Nadia: And then there's the query forgery side. They suggest that for an AI system to resist forging queries, even if a curious user estimates a policy-specific transformation, they still need the actual secret key to construct a query accepted under an unauthorized policy.
Elias: That’s a strong point because it shifts the burden from just making the embedding look different to requiring genuine knowledge of the secret key for successful forgery. It makes that forgery much harder for a curious user who doesn't have access to those keys.
Priya: But we also need to address policy membership hiding, which they pointed out earlier is not achieved by isolation alone. They suggest that even when retrieval is blocked, the geometric separation can still reveal which policy a representation belongs to through some kind of clustering analysis.
Nadia: So the authors are basically saying that you need these extra layers—noise for confidentiality and key-based checks for forgery—on top of just using geometric transformations for isolation. It’s about building a more layered defense, not just picking one geometric trick.
Elias: And looking at the scale, they noted that as the embedding dimension gets bigger, like going from three hundred eighty four to one thousand twenty-four the cost for forgery resistance can still increase if you rely on secret per-policy transformations.
Priya: That’s a caveat we need to watch—the complexity of your protection actually affects the cost of an attack depending on how big your embedding space is. It’s not a fixed security level.
Nadia: So, the improvement direction here is clearly toward making these geometric methods more robust against reconstruction and forgery by adding explicit noise or requiring secret keys for queries.
Elias: It also means that isolation isn't the final word; you still have to fight those membership leaks through clustering analysis, which is a different kind of attack entirely.
Priya: It’s clear then that moving forward, if you use this geometry, your security strategy has to be multi-faceted—you need noise for privacy and key-based checks for access.
Nadia: So the next big question is how much of this layered defense we actually have to implement in a real production RAG system before it becomes too complicated or slow.
Conclusion: Nadia: So we're wrapping up our look at "Isolation Is Not Confidentiality: Security Boundaries of Geometric Access Control in RAG." Basically, this paper shows that while geometric transformations give you strong isolation between policies, it doesn't automatically handle confidentiality or forgery resistance on its own.
Elias: They proved that you can recover the original embedding from a few hundred aligned pairs if you’re lucky, and they showed how query forgery cost scales with the dimension of your embedding space if those per-policy transformations are secret.
Priya: From my side, what this means is that for RAG systems, isolation is just one layer of defense. You still have to actively design mechanisms to prevent reconstruction and membership leaks separately.
Nadia: Exactly. It's not a magic shield; it's just one piece of the puzzle in securing your data pipeline.
Elias: It’s a cautionary note that the math shows us, and it’s helpful for anyone designing these kinds of systems to know what the costs look like as they scale up.
Priya: I think we need to keep asking those questions about which security objectives are most critical for your specific use case before you build something on this geometric foundation.
Nadia: Well, that’s it for this paper on "Isolation Is Not Confidentiality: Security Boundaries of Geometric Access Control in RAG." We'll take a quick break and then we'll be diving into Honeyval next to see how they’re tackling evaluation frameworks for LLM-powered honeypots.
Elias: Indeed. We’ll be back after the break with that discussion.
More episodes
- 2608.27496-ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection
- Daily Summary for 2026-11-19
- 2607.07085-Is Randomness Necessary for Adaptive Data Analysis?
- The day in conversation for 2026-11-19
- Daily Summary for 2026-11-19
- 2609.10601-Threshold Choice, Not Sample Size, Bounds Trustless Verification of Nondeterministic Compound AI Workflows
- 2610.38786-Adversarial Process Disturbances at a Deployable Alarm Budget: Detector Evaluation on a Simulator and a Real Plant
- 2511.08660-Binary and Multiclass Cyberattack Classification on GeNIS Dataset
- 2604.27302-Static Attribution of Android Residential Proxy Malware Using Graph Kernels
- Daily Summary for 2026-11-18