Oblivis: A Framework for Delegated and Efficient Oblivious Transfer
Aydin Abadi (Paper author · Newcastle University), Yvo Desmedt (Paper author · The University of Texas at Dallas)
Privacy Enhancing Technologies Symposium (PETS) 2026 · Day 3 · Moose
Overview
Oblivious Transfer (OT) is a foundational cryptographic primitive that enables two parties to exchange information with robust privacy guarantees. In its classical form, a client can retrieve a specific record from a server's database without revealing which record was requested, while the server learns nothing about the client's query. Despite its elegance and theoretical significance, traditional OT protocols often struggle to meet the demands of modern computing environments, particularly when dealing with resource-constrained clients or complex data management architectures.

Key moments
- 0:00 Introduction to OT and modern challenges
- 4:56 Oblivis framework overview: setting and performance
- 6:10 Delegated Query OT protocol explanation
- 10:00 Unknown Query OT: client doesn't know index
- 11:10 SuperSonic OT: information-theoretic secure protocol
- 11:40 Implementation results and performance overview
Oblivis: A Framework for Delegated and Efficient Oblivious Transfer
Speakers: Aydin Abadi (Paper author, Newcastle University); Yvo Desmedt (Paper author, The University of Texas at Dallas)
Conference: PETS
YouTube: https://www.youtube.com/watch?v=qqeFtZ_wGF8
Overview
Oblivious Transfer (OT) is a foundational cryptographic primitive that enables two parties to exchange information with robust privacy guarantees. In its classical form, a client can retrieve a specific record from a server's database without revealing which record was requested, while the server learns nothing about the client's query. Despite its elegance and theoretical significance, traditional OT protocols often struggle to meet the demands of modern computing environments, particularly when dealing with resource-constrained clients or complex data management architectures.
This talk, presented by Aydin Abadi and Yvo Desmedt at PETS, introduces Oblivis, a novel framework designed to extend the utility and efficiency of Oblivious Transfer to address these contemporary challenges. The speakers highlight critical scenarios where classical OT falls short, such as interactions involving "thin clients" with limited computational power, settings requiring delegated computation to intermediaries, or multi-tenant database environments where data from various organizations (e.g., BBC, Boots, British Airways) is merged. Oblivis offers a suite of protocols tailored to these specific contexts, aiming to make privacy-preserving data retrieval both practical and efficient.
The importance of the Oblivis framework lies in its ability to bridge the gap between theoretical cryptographic ideals and real-world application needs. By enabling secure information exchange in settings previously deemed impractical for OT, Oblivis paves the way for enhanced privacy in sensitive domains like private banking, cloud computing, and interactions with third-party data providers. The work not only refines existing OT techniques but also introduces innovative approaches, including an information-theoretic secure variant, demonstrating a significant step forward in applied cryptography.
Background
▶ Watch: Introduction to OT and modern challenges (0:00)
The concept of Oblivious Transfer (OT), first proposed approximately 30 years ago, forms a cornerstone of secure multi-party computation. At its core, OT allows a client to select one out of several messages held by a server, such that the client learns only the chosen message, and the server remains oblivious to which message was selected. This fundamental privacy property is invaluable for numerous cryptographic applications. Traditional OT protocols, such as the well-known Naor-Pinkas protocol, achieve this by requiring the client to perform computationally intensive operations, typically involving modular exponentiations, to generate a cryptographically secure query.
While effective, this classical model presents significant limitations in several modern computing paradigms. The speakers specifically identify three key areas where traditional OT proves inadequate:
- Thin Clients: Devices with limited computational resources, such as mobile phones, IoT devices, or embedded systems, cannot efficiently execute the complex cryptographic operations required for classical OT. A naive approach where a thin client encrypts its query and delegates it to an intermediary still necessitates the client to generate its own query, which is computationally expensive and defeats the purpose of being "thin."
- Delegated Computation and Indirect Access: In scenarios like private banking, clients might not have direct access to large, specialized databases. Instead, they interact with intermediaries (e.g., financial advisors) who hold paid subscriptions to these databases. The client needs to delegate the query generation and retrieval process to these intermediaries without revealing their specific query to them. The current OT mechanisms don't inherently support this delegation efficiently while maintaining client privacy against the intermediaries.
- Multi-Tenant Database Settings: A growing trend, particularly among cloud providers, involves merging databases from various companies and organizations. The talk explicitly mentions instances involving BBC, Boots, and British Airways. Applying standard OT techniques directly in such merged environments leads to severe privacy leakages. For example:
- A client might learn the entire merged database, even if only a small portion pertains to them.
- The server might learn which part of the database belongs to which client, compromising data segregation and confidentiality.
- In some extreme cases, the client might not even know the index of the data they are seeking and must not learn it during the process, a scenario not addressed by classical OT where the client explicitly provides an index.
These challenges underscore the need for a more flexible and efficient OT framework that can adapt to diverse computational capabilities and complex data ownership models. The existing elegant protocols, while theoretically sound, were not designed for these specific real-world constraints, necessitating the development of novel approaches like those embodied in Oblivis.
Key Findings
▶ Watch: Delegated Query OT protocol explanation (6:10)
The Oblivis framework represents a significant advancement in the practical application of Oblivious Transfer, offering tailored solutions to the aforementioned limitations of traditional OT. The core findings revolve around the successful development of a dual-class framework: setting-oriented protocols that address specific real-world scenarios, and performance-oriented protocols focused on efficiency.
The setting-oriented class introduces several novel OT variants:
- Delegated Query OT (Client Knows Index): This protocol enables thin clients to outsource the computationally intensive query generation process to semi-honest intermediaries (proxies). The client still holds the private index, but the heavy lifting of modular exponentiations is performed by the proxies, making OT feasible for resource-constrained devices.
- Delegated Unknown Query OT (Client Does Not Know Index): This variant extends delegation to scenarios where the client not only delegates computation but also does not (and should not) know the specific index of the data it wishes to retrieve. This is crucial for applications where the client's privacy extends to the query itself, not just the data content.
- Merged Databases: Oblivis provides solutions for multi-tenant environments by adapting both delegated and unknown query OT protocols to prevent information leakage. It ensures that clients only learn data relevant to them, and servers do not learn which data belongs to which client, addressing critical privacy concerns in cloud-based data aggregation.
The performance-oriented class introduces two key contributions aimed at enhancing the efficiency and deployability of OT:
- Generic Compiler: This component leverages standard techniques from Private Information Retrieval (PIR). By employing homomorphic encryption, the client can encrypt a bit string representing their query, allowing the server to perform computations (e.g., homomorphic dot products) on the encrypted data without decryption, thus maintaining privacy.
- SuperSonic OT: Described as a highlight of the framework, SuperSonic OT is an information-theoretic secure protocol. Its design prioritizes simplicity and ease of implementation, requiring minimal external libraries (only a big integer library, or none in Python). It achieves its security and efficiency through a novel application of a "control swap" technique, often found in quantum cryptography, making it highly attractive for practical deployment where strong security guarantees are paramount.
In essence, Oblivis's key findings are that it is possible to:
- Enable Oblivious Transfer for thin clients by delegating the complex cryptographic computations to trusted intermediaries.
- Protect privacy in multi-tenant environments by preventing unintended information leakage to both clients and servers when databases are merged.
- Support scenarios where the client's query itself is sensitive or unknown to the client.
- Develop highly efficient and information-theoretically secure OT protocols that are easy to implement.
These findings collectively expand the applicability of Oblivious Transfer from a theoretical construct to a versatile tool capable of addressing complex, real-world privacy challenges across various computational settings.
Technical Deep Dive
▶ Watch: Unknown Query OT: client doesn't know index (10:00)
The Oblivis framework introduces several sophisticated technical mechanisms to achieve its goals of delegated and efficient Oblivious Transfer. The core innovations lie in how it handles query generation, leverages secure multi-party computation primitives, and optimizes for different performance and security requirements.
Delegated Query OT (Client Knows Index)
The foundational concept for enabling thin clients is Delegated Query OT. In the classical Naor-Pinkas OT protocol, the client (receiver) generates a pair of queries, one for each possible server message, such that only the desired message can be decrypted. This involves computationally expensive operations, primarily modular exponentiations. Oblivis delegates these operations to semi-honest, non-colluding proxies.
Here's a breakdown of the process:
- Client's Role: The receiver (client) possesses a private index
S(e.g., 0 or 1 for a 1-out-of-2 OT). Instead of directly computing the query, the client performs a very cheap operation: XOR-based secret sharing. It splits its indexSinto two shares,s1ands2, such thats1 XOR s2 = S. - Proxy Interaction:
- The client sends
s1(and some random padding) to Proxy 1 (P1) ands2(and another random padding) to Proxy 2 (P2). - The proxies are assumed to be semi-honest (they follow the protocol but may try to learn information) and non-colluding (they do not share their information with each other). This non-collusion assumption is critical for security.
- P2, upon receiving its share
s2and random material, performs some computation, which involves "rotating" two messages it creates. It then sends the result of this computation to P1. - P1, having received its share
s1, its random material, and the output from P2, performs further computations.
- Query to Server: The final output from P1 is a pair of queries, which are then sent to the sender (server). A key insight of Oblivis is that "the query that sent by the last proxy to the sender is similar to the traditional OT, classical OT, proposed by Naor-Pinkas." This means the server-side logic of the OT protocol can remain largely unchanged, simplifying integration and leveraging existing security analyses.
- Server and Client Decryption: The server performs its standard OT computations based on these queries, encodes its messages, and sends the resulting ciphertext to the client. The client, having delegated the expensive query generation, can now easily decrypt the received message using its original index
S.
The critical advantage here is that the modular exponentiations and other heavy cryptographic computations are offloaded to the proxies, making the client's role computationally trivial. The client "basically does nothing" beyond secret sharing and final decryption, which are very cheap operations.
Delegated Unknown Query OT
This variant extends the delegation model to scenarios where the client should not even know the index S itself. The talk briefly mentions this, stating that the paper discusses "why in which situations the client must not know." This implies a more complex interaction where the index might be derived or determined by other parties or conditions, and the client's privacy requires ignorance of this index. The technical details for this specific variant are not fully elaborated in the talk but are noted as a distinct category within the setting-oriented protocols.
Generic Compiler using PIR and Homomorphic Encryption
The framework also includes a generic compiler for OT, which is rooted in techniques from Private Information Retrieval (PIR). PIR allows a user to retrieve an item from a database without revealing which item was retrieved.
- Mechanism: The client constructs a bit string where all bits are zero except for the bit corresponding to the desired index, which is set to one.
- Homomorphic Encryption: This bit string is then encrypted using homomorphic encryption, a powerful cryptographic primitive that allows computations to be performed on ciphertext without ever decrypting it.
- Server Computation: The encrypted query is sent to the server. The server then performs a homomorphic dot product between its own messages (the database records) and the encrypted query. The result of this computation, still in encrypted form, is sent back to the client.
- Client Decryption: The client can then decrypt this result to obtain the desired message. This approach inherently supports the privacy requirement as the server only ever sees encrypted data and performs operations on it without learning the client's specific interest.
SuperSonic OT: Information-Theoretic Security and Control Swap
SuperSonic OT is highlighted as a particularly innovative and practical component of Oblivis.
- Information-Theoretic Security: This is a strong security guarantee, meaning its security does not rely on unproven computational hardness assumptions (like factoring large numbers or discrete logarithms) but rather on the fundamental impossibility of gaining information from random data. This makes it highly resilient against future advances in computation, including quantum computing.
- Simplicity and Efficiency: The speaker emphasizes that SuperSonic OT is "very easy to understand, implement." It requires minimal external dependencies—only a library for big integers, or none at all if programmed in Python due to its native handling of large numbers.
- Control Swap Technique: The core technical innovation comes from a "very cool technique that has been used often in quantum cryptography," specifically a control swap. In this context, two proxies (similar to the delegated OT setup) can "swap their messages based on the share they receive" from the client.
- The client's shares control whether the messages held by the proxies are swapped or remain in their original positions.
- "The last proxy discards the second value and they only always send the first one to the receiver." This implies that based on the control swap, the desired message is moved to a specific position (e.g., the first position), while the other message is effectively discarded or made unretrievable by the client.
- The receiver (client) can then "easily decrypt" the single value it receives, knowing it corresponds to its chosen message.
SuperSonic OT's blend of information-theoretic security, simplicity, and efficiency makes it a compelling choice for environments demanding robust privacy with minimal overhead. The utilization of a quantum-inspired control swap demonstrates a creative application of advanced cryptographic concepts to classical computing problems.
Demo / Proof of Concept
▶ Watch: SuperSonic OT: information-theoretic secure protocol (11:10)
While the talk did not feature a live, interactive demonstration, the speakers confirmed that the Oblivis framework, particularly its various OT protocols, has undergone practical implementation and performance evaluation. This serves as a crucial Proof of Concept (PoC), validating the feasibility and efficiency claims of their theoretical work.
Specifically, the implementation efforts were carried out on two distinct platforms:
- MacBook Pro: A standard high-performance computing environment, representing typical developer workstations or more powerful client devices.
- Raspberry Pi 4: A popular single-board computer known for its low cost and energy efficiency, serving as a representative "thin client" or edge device with constrained resources.
The outcome of these implementations was positive, with the speaker stating, "And the performance was accepted [acceptable]." This indicates that the protocols within the Oblivis framework—including the delegated query OT and SuperSonic OT—are not only theoretically sound but also perform adequately in real-world computational settings, even on resource-limited hardware like the Raspberry Pi. This empirical validation is vital for demonstrating the practical utility of Oblivis in scenarios involving thin clients and distributed computing.
Defensive Implications
▶ Watch: Implementation results and performance overview (11:40)
The Oblivis framework offers significant defensive implications for organizations and individuals striving to enhance data privacy and security in increasingly complex digital environments. By addressing the limitations of traditional Oblivious Transfer, Oblivis provides practical tools for defenders facing challenges related to thin clients, delegated data access, and multi-tenant cloud architectures.
- Enabling Secure Access for Thin Clients: For organizations deploying applications to resource-constrained devices (e.g., IoT endpoints, mobile devices, embedded systems), Oblivis provides a robust method for secure data retrieval. Defenders can leverage delegated query OT to allow these "thin clients" to access sensitive databases without requiring them to perform heavy cryptographic computations. This expands the scope of secure data interactions to a wider array of devices that previously could not participate in privacy-preserving protocols due to computational limitations.
- Enhancing Privacy in Delegated Data Access: In scenarios where clients rely on intermediaries (like financial advisors or data brokers) to access proprietary databases, Oblivis offers a way to maintain client query privacy. Defenders can implement Oblivis protocols to ensure that while intermediaries facilitate data retrieval, they remain oblivious to the specific queries made by the end-client. This is particularly relevant for sectors like private banking or healthcare, where client queries contain highly sensitive information.
- Mitigating Leakage Risks in Multi-Tenant Environments: Cloud providers and enterprises that consolidate data from multiple tenants into merged databases face significant challenges in preventing cross-client data leakage and ensuring data segregation. Oblivis provides cryptographic mechanisms to address these issues. By deploying Oblivis's specialized protocols for merged databases, defenders can ensure that:
- Clients only learn the specific records they are authorized to access, preventing them from inferring information about other tenants' data.
- The server (cloud provider) does not learn which part of the database belongs to which client, thereby preserving client anonymity and preventing the server from profiling client behavior based on their queries. This directly tackles the privacy concerns raised by the speaker regarding cloud providers merging data from entities like BBC, Boots, and British Airways.
- Adopting Information-Theoretic Security: The inclusion of SuperSonic OT, an information-theoretic secure protocol, provides defenders with an option for the strongest possible security guarantees. For highly sensitive applications where long-term security against future computational advancements (including quantum computing) is paramount, SuperSonic OT offers a robust solution. Its simplicity and efficiency further reduce the barrier to adopting such high-assurance cryptographic primitives.
- Secure Proxy Design and Management: The delegated OT protocols rely on semi-honest, non-colluding proxies. Defenders must carefully consider the security implications of this assumption. This may involve:
- Trust Distribution: Employing multiple, independent proxy services to minimize the risk of collusion.
- Auditing and Monitoring: Implementing robust auditing and monitoring mechanisms for proxy operations.
- Legal and Contractual Agreements: Establishing strong contractual obligations with proxy providers to ensure adherence to the semi-honest model.
- Zero-Trust Principles: While proxies are semi-honest, applying zero-trust principles to their interaction with sensitive data can further enhance overall security posture.
By integrating the Oblivis framework, organizations can proactively address emerging privacy challenges, strengthen their defensive capabilities against information leakage, and expand the secure use of data in complex, distributed computing environments.
Key Takeaways
- Traditional Oblivious Transfer (OT) protocols are insufficient for modern applications involving thin clients, delegated computation, and multi-tenant databases due to computational overhead and privacy leakages.
- The Oblivis framework introduces "setting-oriented" and "performance-oriented" OT variants to specifically address these real-world limitations, making OT practical for diverse environments.
- Delegated Query OT enables thin clients by offloading computationally expensive operations, such as modular exponentiations, to semi-honest and non-colluding proxies, while maintaining client query privacy.
- Oblivis provides robust solutions for multi-tenant environments by preventing clients from learning extraneous database information and ensuring servers remain oblivious to client-specific data ownership.
- SuperSonic OT offers an information-theoretic secure, highly efficient, and easy-to-implement OT protocol, leveraging a "control swap" technique inspired by quantum cryptography.
- The framework's protocols have been successfully implemented and tested on platforms ranging from MacBook Pro to Raspberry Pi 4, demonstrating practical feasibility and acceptable performance for real-world deployment.
About the Speaker(s)
Aydin Abadi is a paper author affiliated with Newcastle University. Yvo Desmedt is also a paper author, representing The University of Texas at Dallas. Together, they presented the Oblivis framework, a significant contribution to the field of cryptographic protocols and their practical applications.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Desmedt and Abadi brought actual cryptographic engineering to PETS, taking classical Naor-Pinkas OT and making it survivable for thin clients. They offload the heavy modular exponentiation to proxies and use a quantum-inspired control swap for information-theoretic security. It's heavy academic crypto, but it actually compiles and runs on a Raspberry Pi.
Heather Calloway (CISO) — SOLID
This is academic cryptographic research that solves a practical business problem: how to query multi-tenant cloud databases or use thin clients without leaking user intent or exposing adjacent enterprise data. It is not a tool your security operations team will deploy today, but it signals where privacy-enhancing commercial architectures are heading.
→ Top-rated talks at Privacy Enhancing Technologies Symposium (PETS) 2026
All talks from Privacy Enhancing Technologies Symposium (PETS) 2026