$\mathcal{E}\text{psolute}$: Efficiently Querying Databases While Providing Differential Privacy

TL;DR

This paper introduces $ ext{Epsolute}$, a scalable, efficient system that enables privacy-preserving database queries using differential privacy and cryptographic techniques, suitable for real-world deployment.

Contribution

The work presents a novel, practical construction combining Oblivious RAM and differential privacy for secure outsourced databases, with improvements for efficiency and scalability.

Findings

Supports up to 10 million records with high efficiency

Less than tenfold slowdown compared to standard RDBMS

Proven privacy guarantees against untrusted servers

Abstract

As organizations struggle with processing vast amounts of information, outsourcing sensitive data to third parties becomes a necessity. To protect the data, various cryptographic techniques are used in outsourced database systems to ensure data privacy, while allowing efficient querying. A rich collection of attacks on such systems has emerged. Even with strong cryptography, just communication volume or access pattern is enough for an adversary to succeed. In this work we present a model for differentially private outsourced database system and a concrete construction, $\mathcal{E}\text{psolute}$, that provably conceals the aforementioned leakages, while remaining efficient and scalable. In our solution, differential privacy is preserved at the record level even against an untrusted server that controls data and queries. $\mathcal{E}\text{psolute}$ combines Oblivious RAM and differentially private sanitizers to create a generic and efficient construction. We go further and present a set of improvements to bring the solution to efficiency and practicality necessary for real-world adoption. We describe the way to parallelize the operations, minimize the amount of noise, and reduce the number of network requests, while preserving the privacy guarantees. We have run an extensive set of experiments, dozens of servers processing up to 10 million records, and compiled a detailed result analysis proving the efficiency and scalability of our solution. While providing strong security and privacy guarantees we are less than an order of magnitude slower than range query execution of a non-secure plain-text optimized RDBMS like MySQL and PostgreSQL.

Equations

$$\text{Pr}\left[\text{textsc}A\left({\mathcal{D}}_1\right)\in \mathcal{O}\right]\le \exp (ϵ)\cdot \text{Pr}\left[\text{textsc}A\left({\mathcal{D}}_2\right)\in \mathcal{O}\right]+\delta .$$

$$\begin{gathered} \text{Pr}\left[\mathcal{A}\left(1^{\lambda },{\text{textsc}View}_{\Pi }\left(\mathcal{D},q_1,\dots ,q_m\right)\right)=1\right]\le \\ \exp ϵ\cdot \text{Pr}\left[\mathcal{A}\left(1^{\lambda },{\text{textsc}View}_{\Pi }\left({\mathcal{D}}^{\prime },q_1,\dots ,q_m\right)\right)=1\right]+\delta +\text{negl}, \end{gathered}$$

$${\text{textsc}View}_1\to {\text{textsc}View}_2\to {\text{textsc}View}_3\to {\text{textsc}View}_4.$$

$$\text{Pr}\left[\mathcal{A}({\text{textsc}View}_1)\right]-\text{Pr}\left[\mathcal{A}({\text{textsc}View}_2)\right]\le {\eta }_2.$$

$$\text{Pr}\left[\mathcal{A}({\text{textsc}View}_2)\right]=\exp (ϵ)\cdot \text{Pr}\left[\mathcal{A}({\text{textsc}View}_3)\right]+\delta .$$

$$\text{Pr}\left[\mathcal{A}({\text{textsc}View}_3)\right]-\text{Pr}\left[\mathcal{A}({\text{textsc}View}_4)\right]\le {\eta }_2.$$

$${\left(1-\frac{1}{2}{e}^{-{\alpha }_p\cdot ϵ}\right)}^N\le 1-\beta$$

$${\alpha }_p=\text{ceil}-\frac{\ln \left(2-2\sqrt[N]{1-\beta }\right)}{ϵ}$$

$${\left(1-\frac{1}{2}{e}^{-\frac{{\alpha }_h\cdot ϵ}{{\log }_{k}N}}\right)}^{\mathsf{nodes}}\le 1-\beta$$

$${\alpha }_h=\text{ceil}-\frac{\ln (2-2\sqrt[\mathsf{nodes}]{1-\beta })\cdot {\log }_{k}N}{ϵ}$$

$$\text{Pr}\left[\sum _{i=1}^{k_0}{X}_i>(1+\gamma )\frac{k_0}{m}\right]\le \exp \left(-\frac{k_0{\gamma }^2}{3m}\right)$$

Full text

In this work we present a model for differentially private outsourced database system and a concrete construction, $\mathcal{E}$psolute, that provably conceals the aforementioned leakages, while remaining efficient and scalable. In our solution, differential privacy is preserved at the record level even against an untrusted server that controls data and queries. $\mathcal{E}$psolute combines Oblivious RAM and differentially private sanitizers to create a generic and efficient construction.

We go further and present a set of improvements to bring the solution to efficiency and practicality necessary for real-world adoption. We describe the way to parallelize the operations, minimize the amount of noise, and reduce the number of network requests, while preserving the privacy guarantees. We have run an extensive set of experiments, dozens of servers processing up to 10 million records, and compiled a detailed result analysis proving the efficiency and scalability of our solution. While providing strong security and privacy guarantees we are less than an order of magnitude slower than range query execution of a non-secure plain-text optimized RDBMS like MySQL and PostgreSQL.

Differential Privacy; ORAM; differential obliviousness; sanitizers;

††journalyear: 2021††copyright: acmlicensed††conference: Proceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Security; November 15–19, 2021; Virtual Event, Republic of Korea††booktitle: Proceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Security (CCS ’21), November 15–19, 2021, Virtual Event, Republic of Korea††price: 15.00††doi: 10.1145/3460120.3484786††isbn: 978-1-4503-8454-4/21/11††ccs: Security and privacy Database and storage security††ccs: Security and privacy Management and querying of encrypted data

1. Introduction

Secure outsourced database systems aim at helping organizations outsource their data to untrusted third parties, without compromising data confidentiality or query efficiency. The main idea is to encrypt the data records before uploading them to an untrusted server along with an index data structure that governs which encrypted records to retrieve for each query. While strong cryptographic tools can be used for this task, existing implementations such as CryptDB (Popa et al., 2011), Cipherbase (Arasu et al., 2013b), StealthDB (Vinayagamurthy et al., 2019) and TrustedDB (Bajaj and Sion, 2013) try to optimize performance but do not provide strong security guarantees when answering queries. Indeed, a series of works (Hore et al., 2012; Islam et al., 2014; Cash et al., 2015; Naveed et al., 2015; Kellaris et al., 2016; Bindschaedler et al., 2018; Grubbs et al., 2017; Islam et al., 2012; Lacharité et al., 2018) demonstrate that these systems are vulnerable to a variety of reconstruction attacks. That is, an adversary can fully reconstruct the distribution of the records over the domain of the indexed attribute. This weakness is prominently due to the access pattern leakage: the adversary can tell if the same encrypted record is returned on different queries.

More recently, (Kellaris et al., 2016; Kornaropoulos et al., 2020; Lacharité et al., 2018; Grubbs et al., 2018; Gui et al., 2019) showed that reconstruction attacks are possible even if the systems employ heavyweight cryptographic techniques that hide the access patterns, such as homomorphic encryption (Gentry, 2010; Vaikuntanathan, 2011) or Oblivious RAM (ORAM) (Goldreich, 1987; Goldreich and Ostrovsky, 1996), because they leak the size of the result set of a query to the server (this is referred to as communication volume leakage). Thus, even some recent systems that provide stronger security guarantees like ObliDB (Eskandarian and Zaharia, 2019), Opaque (Zheng et al., 2017) and Oblix (Mishra et al., 2018) are susceptible to these attacks. This also means that no outsourced database system can be both optimally efficient and privacy-preserving: secure outsourced database systems should not return the exact number of records required to answer a query.

We take the next step towards designing secure outsourced database systems by presenting novel constructions that strike a provable balance between efficiency and privacy. First, to combat the access pattern leakage, we integrate a layer of ORAM storage in our construction. Then, we bound the communication volume leakage by utilizing the notion of differential privacy (DP) (Dwork et al., 2006b). Specifically, instead of returning the exact number of records per query, we only reveal perturbed query answer sizes by adding random encrypted records to the result so that the communication volume leakage is bounded. Our construction guarantees privacy of any single record in the database which is necessary in datasets with stringent privacy requirements. In a medical HIPAA-compliant setting, for example, disclosing that a patient exists in a database with a rare diagnosis correlating with age may be enough to reveal a particular individual.

The resulting mechanism achieves the required level of privacy, but implemented naïvely the construction is prohibitively slow. We make the solution practical by limiting the amount of noise and the number of network roundtrips while preserving the privacy guarantees. We go further and present a way to parallelize the construction, which requires adapting noise-generation algorithms to maintain differential privacy requirements.

Using our system, we have run an extensive set of experiments over cloud machines, utilizing large datasets — that range up to 10 million records — and queries of different sizes, and we report our experimental results on efficiency and scalability. We compare against best possible solutions in terms of efficiency (conventional non-secure outsourced database systems on unencrypted data) and against an approach that provides optimal security (retrieves the full table from the cloud or runs the entire query obliviously with maximal padding). We report that our solution is very competitive against both baselines. Our performance is comparable to that of unsecured plain-text optimized database systems (like MySQL and PostgreSQL): while providing strong security and privacy guarantees, we are only 4 to 8 times slower in a typical setting. Compared with the optimally secure solution, a linear scan (downloading all the records), we are 18 times faster in a typical setting and even faster as database sizes scale up.

To summarize, our contributions in this work are as follows:

• •

We present a new model for a differentially private outsourced database system, CDP-ODB, its security definition, query types, and efficiency measures. In our model, the adversarial honest-but-curious server cannot see the record values, access patterns, or exact communication volume.

• •

We describe a novel construction, $\mathcal{E}$psolute, that satisfies the proposed security definition, and provide detailed algorithms for both range and point query types. In particular, to conceal the access pattern and communication volume leakages, we provide a secure storage construction, utilizing a combination of Oblivious RAM (Goldreich, 1987; Goldreich and Ostrovsky, 1996) and differentially private sanitization (Blum et al., 2013). Towards this, we maintain an index structure to know how many and which objects we need to retrieve. This index can be stored locally for better efficiency (in all our experiments this is the case), but crucially, it can also be outsourced to the adversarial server and retrieved on-the-fly for each query.

• •

We improve our generic construction to enable parallelization within a query. The core idea is to split the storage among multiple ORAMs, but this requires tailoring the overhead required for differential privacy proportionally to the number of ORAMs, in order to ensure privacy. We present practical improvements and optimization techniques that dramatically reduce the amount of fetched noise and the number of network roundtrips.

• •

Finally, we provide and open-source a high-quality C++ implementation of our system. We have run an extensive set of experiments on both synthetic and real datasets to empirically assess the efficiency of our construction and the impact of our improvements. We compare our solutions to the naïve approach (linear scan downloading all data every query), oblivious processing and maximal padding solution (Shrinkwrap (Bater et al., 2018)), and to a non-secure regular RDBMS (PostgreSQL and MySQL), and we show that our system is very competitive.

1.1. Related Work

We group the related secure databases, engines, and indices into three categories

(i) systems that are oblivious or volume-hiding and do not require trusted execution environment (TEE),

(ii) constructions that rely on TEE (usually, Intel SGX),

(iii) solutions that use property-preserving or semantically secure encryption and target primarily a snapshot adversary.

We claim that $\mathcal{E}$psolute is the most secure and practical range- and point-query engine in the outsourced database model, that protects both access pattern (AP) and communication volume (CV) using Differential Privacy, while not relying on TEE, linear scan or padding result size to the maximum.

Obliviousness and volume-hiding without enclave

This category is the most relevant to $\mathcal{E}$psolute, wherein the systems provide either or both AP and CV protection without relying on TEE. Crypt$\epsilon$ (Roy Chowdhury et al., 2020) is a recent end-to-end system executing “DP programs”. Crypt$\epsilon$ has a different model than $\mathcal{E}$psolute in that it assumes two non-colluding servers, an adversarial querying user (the analyst), and it uses DP to protect the privacy of an individual in the database, which includes volume-hiding for aggregate queries. Crypt$\epsilon$ also does not consider oblivious execution and attacks against the AP. Shrinkwrap (Bater et al., 2018) (and its predecessor SMCQL (Bater et al., 2017)) is an excellent system designed for complex queries over federated and distributed data sources. In Shrinkwrap, AP protection is achieved by using oblivious operators (linear scan and sort) and CV is concealed by adding fake records to intermediate results with DP. Padding the result to the maximum size first and doing a linear scan over it afterwards to “shrink” it using DP, is much more expensive than in $\mathcal{E}$psolute, however. In addition, in processing a query, the worker nodes are performing an $O(n\log{n})$ cost oblivious sorting, where $n$ is the maximum result size (whole table for range query), since they are designed to answer more general complex queries. SEAL (Demertzis et al., 2020) offers adjustable AP and CV leakages, up to specific bits of leakage. SEAL builds on top of Logarithmic-SRC (Demertzis et al., 2016), splits storage into multiple ORAMs to adjust AP, and pads results size to a power of 2 to adjust CV. $\mathcal{E}$psolute, on the other hand, fully hides the AP and uses DP with its guarantees to pad the result size. PINED-RQ (Sahin et al., 2018) samples Laplacian noise right in the B+ tree index tree, adding fake and removing real pointers according to the sample. Unlike $\mathcal{E}$psolute, PINED-RQ allows false negatives (i.e., result records not included in the answer), and does not protect against AP leakage. On the theoretical side, Chan et al. (2019) (followed by Beimel et al. (2019)) treat the AP itself as something to protect with DP. (Chan et al., 2019) introduces a notion of differential obliviousness that is admittedly weaker than the full obliviousness used in $\mathcal{E}$psolute. Most importantly, (Chan et al., 2019) ensures differential privacy w.r.t. the ORAM only, while $\mathcal{E}$psolute ensures DP w.r.t. the entire view of the adversary.

Enclave-based solutions

Works in this category use trusted execution environment (usually, SGX enclave). These works are primarily concerned with the AP protection for both trusted and untrusted memory, unlike $\mathcal{E}$psolute which also protects CV. Cipherbase (Arasu et al., 2013b; Arasu et al., 2013a) was a pioneer introducing the idea of using TEE (FPGA at that time) to assist with DBMS security. HardIDX (Fuhry et al., 2017) simply puts the B+ tree in the enclave, while StealthDB (Vinayagamurthy et al., 2019) symmetrically encrypts all records and brings them in the enclave one at a time for processing. EnclaveDB (Priebe et al., 2018) assumes somewhat unrealistic $192\text{\,}\mathrm{GB}\text{/}$ enclave and puts the entire database in it. ObliDB (Eskandarian and Zaharia, 2019) and Opaque (Zheng et al., 2017) assume fully oblivious enclave memory (not available as of today) and devise algorithms that use this fully trusted portion to obliviously execute common DBMS operators, like filters and joins. Oblix (Mishra et al., 2018) provides a multimap that is oblivious both in and out of the enclave. HybrIDX claims protection against both AP and CV leakages, but unlike $\mathcal{E}$psolute it only obfuscates them. $\mathcal{E}$psolute offers an indistinguishability guarantee for AP and a DP guarantee for CV, while HybrIDX hides the exact result size and only obfuscates the AP. Lastly, Hermetic (Xu et al., 2019) takes on the SGX side-channel attacks, including AP. It provides oblivious primitives, however, it only offers protection against software and not physical attacks (e.g., it trusts a hypervisor to disable interrupts).

Solutions against the snapshot adversary

Works in this category protect against the snapshot adversary, which takes a snapshot of the data at a fixed point in time (e.g., stolen hard drive). We stress that $\mathcal{E}$psolute provides semantic security against the snapshot adversary on top of AP and CV protection. CryptDB (Popa et al., 2011) is a seminal work in this direction offering computations over encrypted data. It has since been shown (e.g. (Naveed et al., 2015; Islam et al., 2014; Bindschaedler et al., 2018)) that the underlying property-preserving schemes allow for reconstruction attacks. Arx (Poddar et al., 2019) provides strictly stronger security guarantees by using only semantically secure primitives. Seabed (Papadimitriou et al., 2016) uses an additively symmetric homomorphic encryption scheme for aggregates and certain filter queries. Samanthula et al. (2014) offer a method to verify and apply a predicate (a junction of conditions) using garbled circuits or homomorphic encryption without revealing the predicate itself. SisoSPIR (Ishai et al., 2016) presents a mechanism to build an oblivious index tree such that neither party learns the pass taken. See (Bogatov et al., 2019) for a survey of range query protocols in this category.

2. Background

In this section we describe an outsourced database system adapted from (Kellaris et al., 2016), a base for our own model (Section 3), and the constructions we will use as building blocks in our solution.

2.1. Outsourced Database System

We abstract a database as a collection of $n$ records $r$, each with a unique identifier $r^{\mathsf{ID}}$, associated with search keys SK: $\mathcal{D}=\allowbreak\{(r_{1},\allowbreak r^{\mathsf{ID}}_{1},\allowbreak\textsf{SK}_{1}),\allowbreak\ldots,\allowbreak(r_{n},\allowbreak r^{\mathsf{ID}}_{n},\allowbreak\textsf{SK}_{n})\}$. We assume that all records have an identical fixed bit-length, and that search keys are elements of the domain $\mathcal{X}=\{1,\ldots,N\}$ for some $N\in\NN$. Outsourced database systems support search keys on multiple attributes, with a set of search keys for each of the attributes of a record. For the ease of presentation, we describe the model for a single indexed attribute and then show how to extend it to support multiple attributes.

A query is a predicate ${q}:\mathcal{X}\to\bin$. Evaluating a query $q$ on a database $\mathcal{D}$ results in ${q}(\mathcal{D})=\{r_{i}:{q}(\textsf{SK}_{i})=1\}$, all records whose search keys satisfy ${q}$.

Let $\mathcal{Q}$ be a set of queries. An outsourced database system for queries in $\mathcal{Q}$ consists of two protocols between two stateful parties: a user $\mathscr{U}$ and a server $\mathscr{S}$ (adapted from (Kellaris et al., 2016)):

**Setup protocol $\Pi_{\mathsf{setup}}$:: **

$\mathscr{U}$ receives as input a database $\mathcal{D}=\allowbreak\{(r_{1},\allowbreak r^{\mathsf{ID}}_{1},\allowbreak\textsf{SK}_{1}),\allowbreak\ldots,\allowbreak(r_{n},\allowbreak r^{\mathsf{ID}}_{n},\allowbreak\textsf{SK}_{n})\}$; $\mathscr{S}$ has no input. The output for $\mathscr{S}$ is a data structure $\mathcal{DS}$; $\mathscr{U}$ has no output besides its state.

**Query protocol $\Pi_{\mathsf{query}}$:: **

$\mathscr{U}$ has a query ${q}\in\mathcal{Q}$ produced in the setup protocol as input; $\mathscr{S}$ has as input $\mathcal{DS}$ produced in the setup protocol. $\mathscr{U}$ outputs ${q}(\mathcal{D})$; $\mathscr{S}$ has no formal output. (Both parties may update their internal states.)

For correctness, we require that for any database $\mathcal{D}=\allowbreak\{(r_{1},\allowbreak r^{\mathsf{ID}}_{1},\allowbreak\textsf{SK}_{1}),\allowbreak\ldots,\allowbreak(r_{n},\allowbreak r^{\mathsf{ID}}_{n},\allowbreak\textsf{SK}_{n})\}$ and query ${q}\in\mathcal{Q}$, it holds that running $\Pi_{\mathsf{setup}}$ and then $\Pi_{\mathsf{query}}$ on the corresponding inputs yields for $\mathscr{U}{}$ the correct output $\{r_{i}:{q}(\textsf{SK}_{i})=1\}$ with overwhelming probability over the coins of the above runs. We call the protocol $\eta$-wrong if this probability is at least $1-\eta$.

2.2. Differential Privacy and Sanitization

Differential privacy is a definition of privacy in analysis that protects information that is specific to individual records. More formally, we call databases $\mathcal{D}_{1}\in\mathcal{X}^{n}$ and $\mathcal{D}_{2}\in\mathcal{X}^{n}$ over domain $\mathcal{X}$ neighboring (denoted $\mathcal{D}_{1}\sim\mathcal{D}_{2}$) if they differ in exactly one record.

Definition 2.1 ((Dwork et al., 2006a; Dwork

et al., 2006b)).

A randomized algorithm A is $(\epsilon,\delta)$-differentially private if for all $\mathcal{D}_{1}\sim\mathcal{D}_{2}\in\mathcal{X}^{n}$, and for all subsets $\mathcal{O}$ of the output space of A,

[TABLE]

The probability is taken over the random coins of A.

When $\delta=0$ we omit it and say that A preserves pure differential privacy, otherwise (when $\delta>0$) we say that A preserves approximate differential privacy.

We will use mechanisms for answering count queries with differential privacy. Such mechanisms perturb their output to mask out the effect of any single record on their outcome. The simplest method for answering count queries with differential privacy is the Laplace Perturbation Algorithm (LPA) (Dwork et al., 2006b) where random noise drawn from a Laplace distribution is added to the count to be published. The noise is scaled so as to hide the effect any single record can have on the count. More generally, the LPA can be used to approximate any statistical result by scaling the noise to the sensitivity of the statistical analysis.111 The sensitivity of a query $q$ mapping databases into $\RR^{N}$ is defined to be $\Delta({q})=\max_{\mathcal{D}_{1}\sim\mathcal{D}_{2}\in\mathcal{X}^{n}}\norm{{q}(\mathcal{D}_{1})-{q}(\mathcal{D}_{2})}_{1}$.

Theorem 2.2 (adapted Theorem 1 from (Dwork

et al., 2006b)).

Let ${q}:\mathcal{D}\to\RR^{N}$. An algorithm A that adds independently generated noise from a zero-mean Laplace distribution with scale $\lambda=\nicefrac{{\Delta({q})}}{{\epsilon}}$ to each of the $N$ coordinates of ${q}(\mathcal{D})$, satisfies $\epsilon$-differential privacy.

While Theorem 2.2 is an effective and simple way of answering a single count query, we will need to answer a sequence of count queries, ideally, without imposing a bound on the length of this sequence. We will hence make use of sanitization algorithms.

Definition 2.3.

Let $\mathcal{Q}$ be a collection of queries. An $(\epsilon,\delta,\alpha,\beta)$-differentially private sanitizer for $\mathcal{Q}$ is a pair of algorithms $({\textsc{A}},{\textsc{B}})$ such that:

• •

$A$* is $(\epsilon,\delta)$-differentially private, and*

• •

on input a dataset $\mathcal{D}=d_{1},\ldots,d_{n}\in\mathcal{X}^{n}$, A outputs a data structure $\mathcal{DS}$ such that with probability $1-\beta$ for all ${q}\in\mathcal{Q}$, $\abs{{\textsc{B}\left(\mathcal{DS},{q}\right)}-\sum_{i}{q}(d_{i})}\leq\alpha$.

Remark 2.4.

Given an $(\epsilon,\delta,\alpha,\beta)$-differentially private sanitizer as in Definition 2.3 one can replace the answer ${\textsc{B}\left(\mathcal{DS},{q}\right)}$ with $\textsc{B}^{\prime}(\mathcal{DS},\allowbreak{q})={\textsc{B}\left(\mathcal{DS},{q}\right)}+\alpha$. Hence, with probability $1-\beta$, for all ${q}\in\mathcal{Q}$, 0\leq{\textsc{\textsc{B}^{\prime}}\left(\mathcal{DS},{q}\right)}-\sum_{i}{q}(d_{i})\leq 2\alpha. We will hence assume from now on that sanitizers have this latter guarantee on their error.

The main idea of sanitization (a.k.a. private data release) is to release specific noisy statistics on a private dataset once, which can then be combined in order to answer an arbitrary number of queries without violating privacy. Depending on the query type and the notion of differential privacy (i.e., pure or approximate), different upper bounds on the error have been proven. Omitting the dependency on $\epsilon,\delta$, in case of point queries over domain size $N$, pure differential privacy results in $\alpha=\Theta\left(\log N\right)$ (Beimel et al., 2014), while for approximate differential privacy $\alpha=\bigO{1}$ (Beimel et al., 2013). For range queries over domain size $N$, these bounds are $\alpha=\Theta\left(\log N\right)$ for pure differential privacy (Blum et al., 2013; Dwork et al., 2010), and $\alpha=\bigO{(\log^{*}N)^{1.5}}$ for approximate differential privacy (with an almost matching lower bound of $\alpha=\bigOmega{\log^{*}N}$) (Beimel et al., 2013; Bun et al., 2015; Kaplan et al., 2020). More generally, Blum et al. (2013) showed that any finite query set $\mathcal{Q}$ can be sanitized, albeit non-efficiently.

Answering point and range queries with differential privacy

Utilizing the LPA for answering point queries results in error $\alpha=\bigO{\log N}$. A practical solution for answering range queries with error bounds very close to the optimal ones is the hierarchical method (Dwork et al., 2010; Hay et al., 2010; Xiao et al., 2010). The main idea is to build an aggregate tree on the domain, and add noise to each node proportional to the tree height (i.e., noise scale logarithmic in the domain size $N$). Then, every range query is answered using the minimum number of tree nodes. Qardaji et al. (2013) showed that the hierarchical algorithm of Hay et al. (2010), when combined with their proposed optimizations, offers the lowest error.

Composition

Finally, we include a composition theorem (adapted from (McSherry, 2009)) based on (Dwork et al., 2006b; Dwork et al., 2006a). It concerns executions of multiple differentially private mechanisms on non-disjoint and disjoint inputs.

Theorem 2.5.

Let ${\textsc{A}}_{1},\ldots,{\textsc{A}}_{r}$ be mechanisms, such that each ${\textsc{A}}_{i}$ provides $\epsilon_{i}$-differential privacy. Let $\mathcal{D}_{1},\ldots,\mathcal{D}_{r}$ be pairwise non-disjoint (resp., disjoint) datasets. Let A be another mechanism that executes ${\textsc{A}}_{1}(\mathcal{D}_{1}),\ldots,{\textsc{A}}_{r}(\mathcal{D}_{r})$ using independent randomness for each ${\textsc{A}}_{i}$, and returns their outputs. Then, mechanism A is $\left(\sum_{i=1}^{r}\epsilon_{i}\right)$-differentially private (resp., $\left(\max_{i=1}^{r}\epsilon_{i}\right)$-differentially private).

2.3. Oblivious RAM

Informally, Oblivious RAM (ORAM) is a mechanism that lets a user hide their RAM access pattern to remote storage. An adversarial server can monitor the actual accessed locations, but she cannot tell a read from a write, the content of the block or even whether the same logical location is being referenced. The notion was first defined by Goldreich (1987) and Goldreich and Ostrovsky (1996).

More formally, a $(\eta_{1},\eta_{2})$-ORAM protocol is a two-party protocol between a user $\mathscr{U}$ and a server $\mathscr{S}$ who stores a RAM array. In each round, the user $\mathscr{U}$ has input $(o,a,d)$, where $o$ is a RAM operation ($\mathbf{r}$ or $\mathbf{w}$), $a$ is a memory address and $d$ is a new data value, or $\bot$ for read operation. The input of $\mathscr{S}$ is the current array. Via the protocol, the server updates the memory or returns to $\mathscr{U}$ the data stored at the requested memory location, respectively. We speak of a sequence of such operations as a program $\mathbf{y}$ being executed under the ORAM.

An ORAM protocol must satisfy correctness and security. Correctness requires that $\mathscr{U}$ obtains the correct output of the computation except with at most probability $\eta_{1}$. For security, we require that for every user $\mathscr{U}$ there exists a simulator $\textsc{Sim}_{\textsc{ORAM}}$ which provides a simulation of the server’s view in the above experiment given only the number of operations. That is, the output distribution of $\textsc{Sim}_{\textsc{ORAM}}(c)$ is indistinguishable from ${\textsc{View}}_{\mathscr{S}}$ with probability at most $\eta_{2}$ after $c$ protocol rounds.

ORAM protocols are generally stateful, after each execution the client and server states are updated. For brevity, throughout the paper we will assume the ORAM state updates are implicit, including the encryption key $K$ generated and maintained by the client.

Some existing efficient ORAM protocols are Square Root ORAM (Goldreich, 1987), Hierarchical ORAM (Goldreich and Ostrovsky, 1996), Binary-Tree ORAM (Shi et al., 2011), Interleave Buffer Shuffle Square Root ORAM (Xie et al., 2016), TP-ORAM (Stefanov et al., 2012), Path-ORAM (Stefanov et al., 2013) and TaORAM (Sahin et al., 2016). For detailed descriptions of each protocol, we recommend the work of Chang et al. (2016). The latter three ORAMs achieve the lowest communication and storage overheads, $\bigO{\log n}$ and \bigO$n$, respectively.

3. Differentially private outsourced database systems

In this section we present our model, differentially private outsourced database system, CDP-ODB, its security definition, query types and efficiency measures. It is an extension of the ODB model in Section 2.

3.1. Adversarial model

We consider an honest-but-curious polynomial time adversary that attempts to breach differential privacy with respect to the input database $\mathcal{D}$. We observe later in Section 3.1.1 that it is impossible to completely hide the number of records returned on each query without essentially returning all the database records on each query. This, in turn, means that different query sequences may be distinguished, and, furthermore, that differential privacy may not be preserved if the query sequence depends on the content of the database records. We hence, only require the protection of differential privacy with respect to every fixed query sequence. Furthermore, we relax to computational differential privacy (following (Mironov et al., 2009)).

In the following definition, the notation ${\textsc{View}}_{\Pi}{}\left(\mathcal{D},{q}_{1},\ldots,{q}_{m}\right)$ denotes the view of the server $\mathscr{S}$ in the execution of protocol $\Pi$ in answering queries ${q}_{1},\ldots,{q}_{m}$ with the underlying database $\mathcal{D}$.

Definition 3.1.

We say that an outsourced database system $\Pi$ is $(\epsilon,\delta)$-computationally differentially private (a.k.a. CDP-ODB) if for every polynomial time distinguishing adversary $\mathcal{A}$, for every neighboring databases $\mathcal{D}\sim\mathcal{D}^{\prime}$, and for every query sequence ${q}_{1},\ldots,{q}_{m}\in\mathcal{Q}^{m}$ where $m=\mathsf{poly}(\lambda)$,

[TABLE]

where the probability is over the randomness of the distinguishing adversary $\mathcal{A}$ and the protocol $\Pi$.

Remark 3.2 (Informal).

We note that security and differential privacy in this model imply protection against communication volume and access pattern leakages and thus prevent a range of attacks, such as (Cash et al., 2015; Naveed et al., 2015; Kellaris et al., 2016).

3.1.1. On impossibility of adaptive queries

Non-adaptivity in our CDP-ODB definition does not reflect a deficiency of our specific protocol but rather an inherent source of leakage when the queries may depend on the decrypted data. Consider an adaptive CDP-ODB definition that does not fix the query sequence $q_{1},\ldots,q_{m}$ in advance but instead an arbitrary (efficient) user $\mathscr{U}$ chooses them during the protocol execution with $\mathscr{S}$. As before, we ask that the $\mathscr{S}$’s view is DP on neighboring databases for every such $\mathscr{U}$. We observe that this definition cannot possibly be satisfied by any outsourced database system without unacceptable efficiency overhead. Note that non-adaptivity here does not imply that the client knows all the queries in advance, but rather can choose them at any time (e.g., depending on external circumstances) as long as they do not depend on true answers to prior queries.

To see this, consider two neighboring databases $\mathcal{D},\mathcal{D}^{\prime}$. Database $\mathcal{D}$ has 1 record with $\mathsf{key}=0$ and $\mathcal{D}^{\prime}$ has none. Furthermore, both have 50 records with $\mathsf{key}=50$ and 100 records with $\mathsf{key}=100$. User $\mathscr{U}$ queries first for the records with $\mathsf{key}=0$, and then if there is a record with $\mathsf{key}=0$ it queries for the records with $\mathsf{key}=50$, otherwise for the records with $\mathsf{key}=100$. Clearly, an efficient outsourced database system cannot return nearly as many records when $\mathsf{key}=50$ versus $\mathsf{key}=100$ here. Hence, this allows distinguishing $\mathcal{D},\mathcal{D}^{\prime}$ with probability almost 1.

To give a concrete scenario, suppose neighboring medical databases differ in one record with a rare diagnosis “Alzheimer’s disease”. A medical professional queries the database for that diagnosis first (point query), and if there is a record, she queries the senior patients next (range query, age $\geq$ 65), otherwise she queries the general population (resulting in more records). We leave it open to meaningfully strengthen our definition while avoiding such impossibility results, and we defer the formal proof to future work.

3.2. Query types

In this work we are concerned with the following query types:

**Range queries: **

Here we assume a total ordering on $\mathcal{X}$. A query $q_{\interval{a}{b}}$ is associated with an interval $\interval{a}{b}$ for $1\leq a\leq b\leq N$ such that ${q_{\interval{a}{b}}}(c)=1$ iff $c\in\interval{a}{b}$ for all $c\in\mathcal{X}$. The equivalent SQL query is:

SELECT * FROM table WHERE attribute BETWEEN a AND b;

**Point queries: **

Here $\mathcal{X}$ is arbitrary and a query predicate $q_{a}$ is associated with an element $a\in\mathcal{X}$ such that ${q_{a}}(b)=1$ iff $a=b$. In an ordered domain, point queries are degenerate range queries. The equivalent SQL query is:

SELECT * FROM table WHERE attribute = a;

3.3. Measuring Efficiency

We define two basic efficiency measures for a CDP-ODB.

**Storage efficiency: **

is defined as the sum of the bit-lengths of the records in a database relative to the bit-length of a corresponding encrypted database. Specifically, we say that an outsourced database system has storage efficiency of $(a_{1},a_{2})$ if the following holds. Fix any $\mathcal{D}=\allowbreak\{(r_{1},\allowbreak r^{\mathsf{ID}}_{1},\allowbreak\textsf{SK}_{1}),\allowbreak\ldots,\allowbreak(r_{n},\allowbreak r^{\mathsf{ID}}_{n},\allowbreak\textsf{SK}_{n})\}$ and let $n_{1}=\sum_{i=1}^{n}\abs{r_{i}}$. Let $\mathscr{S}_{\mathsf{state}}$ be an output of $\mathscr{S}$ on a run of $\Pi_{\mathsf{setup}}$ where $\mathscr{U}$ has input $\mathcal{D}$, and let $n_{2}=\abs{\mathscr{S}_{\mathsf{state}}}$. Then $n_{2}\leq a_{1}n_{1}+a_{2}$.

**Communication efficiency: **

is defined as the sum of the lengths of the records in bits whose search keys satisfy the query relative to the actual number of bits sent back as the result of a query. Specifically, we say that an outsourced database system has communication efficiency of $(a_{1},a_{2})$ if the following holds. Fix any $q$ and $\mathcal{DS}$ output by $\Pi_{\mathsf{setup}}$, let $\mathscr{U}$ and $\mathscr{S}$ execute $\Pi_{\mathsf{query}}$ where $\mathscr{U}$ has inputs $q$ , and output $R$, and $\mathscr{S}$ has input $\mathcal{DS}$. Let $m_{1}$ be the amount of data in bits transferred between $\mathscr{U}$ and $\mathscr{S}$ during the execution of $\Pi_{\mathsf{query}}$, and let $m_{2}=\abs{R}$. Then $m_{2}\leq a_{1}m_{1}+a_{2}$.

Note that $a_{1}\geq 1$ and $a_{2}\geq 0$ for both measures. We say that an outsourced database system is optimally storage efficient (resp., optimally communication efficient) if it has storage (resp., communication) efficiency of $(1,0)$.

4. $\mathcal{E}$psolute

In this section we present a construction, $\mathcal{E}$psolute, that satisfies the security definition in Section 3, detailing algorithms for both range and point query types. We also provide efficiency guarantees for approximate and pure DP versions of $\mathcal{E}$psolute.

4.1. General construction

Let $\mathcal{Q}$ be a collection of queries. We are interested in building a differentially private outsourced database system for $\mathcal{Q}$, called $\mathcal{E}$psolute. Our solution will use these building blocks.

• •

A $(\eta_{1},\eta_{2})$-ORAM protocol ORAM$\left(\cdot\right)$.

• •

An $(\epsilon,\delta,\alpha,\beta)$-differentially private sanitizer $({\textsc{A}},{\textsc{B}})$ for $\mathcal{Q}$ and negligible $\beta$, which satisfies the non-negative noise guarantee from Remark 2.4.

• •

A pair of algorithms CreateIndex and Lookup. CreateIndex consumes $\mathcal{D}$ and produces an index data structure $\mathcal{I}$ that maps a search key SK to a list of record IDs $r^{\mathsf{ID}}$ corresponding to the given search key. Lookup consumes $\mathcal{I}$ and $q$ and returns a list $T=r^{\mathsf{ID}}_{1},\ldots,r^{\mathsf{ID}}_{\abs{T}}$ of record IDs matching the supplied query.

Our protocol $\Pi=(\Pi_{\mathsf{setup}},\Pi_{\mathsf{query}})$ of $\mathcal{E}$psolute works as shown in Algorithm 1. Hereafter, we reference lines in Algorithm 1. See Fig. 1 for a schematic description of the protocol.

Setup protocol   $\Pi_{\mathsf{setup}}$

Let $\mathscr{U}$’s input be a database $\mathcal{D}=\allowbreak\{(r_{1},\allowbreak r^{\mathsf{ID}}_{1},\allowbreak\textsf{SK}_{1}),\allowbreak\ldots,\allowbreak(r_{n},\allowbreak r^{\mathsf{ID}}_{n},\allowbreak\textsf{SK}_{n})\}$ (Algorithm 1). $\mathscr{U}$ creates an index $\mathcal{I}$ mapping search keys to record IDs corresponding to these keys (Algorithm 1). $\mathscr{U}$ sends over the records to $\mathscr{S}$ by executing the ORAM protocol on the specified sequence (Algorithms 1 to 1). $\mathscr{U}$ generates a DP structure $\mathcal{DS}$ over the search keys using sanitizer A, and sends $\mathcal{DS}$ over to $\mathscr{S}$ (Algorithm 1). The output of $\mathscr{U}$ is $\mathcal{I}$ and of $\mathscr{S}$ is $\mathcal{DS}$; final ORAM states of $\mathscr{S}$ and $\mathscr{U}$ are implicit, including encryption key $K$ (Algorithm 1).

Query protocol   $\Pi_{\mathsf{query}}$

$\mathscr{U}$ starts with a query $q$ and index $\mathcal{I}$, $\mathscr{S}$ starts with a DP structure $\mathcal{DS}$. One can think of these inputs as outputs of $\Pi_{\mathsf{setup}}$ (Algorithm 1). $\mathscr{U}$ immediately sends the query to $\mathscr{S}$, which uses the sanitizer B to compute the total number of requests $c$, while $\mathscr{U}$ uses index $\mathcal{I}$ to derive the true indices of the records the query $q$ targets (Algorithm 1). $\mathscr{U}$ receives $c$ from $\mathscr{S}$ and prepares two ORAM sequences: $\mathbf{y}_{\mathsf{true}}$ for real records retrieval, and $\mathbf{y}_{\mathsf{noise}}$ to pad the number of requests to $c$ to perturb the communication volume. $\mathbf{y}_{\mathsf{noise}}$ includes valid non-repeating record IDs that are not part of the true result set $T$ (Algorithms 1 to 1). $\mathscr{U}$ fetches the records, both real and fake, from $\mathscr{S}$ using the ORAM protocol (Algorithm 1). The output of $\mathscr{U}$ is the filtered set of records requested by the query ${q}$; final ORAM states of $\mathscr{S}$ and $\mathscr{U}$ are implicit (Algorithm 1).

The protocols for point and range queries only differ in sanitizer implementations, see Sections 4.5 and 4.6. Note above that in any execution of $\Pi_{\mathsf{query}}$ we have $c\geq{q}(\mathcal{D})$ with overwhelming probability $1-\beta$ (by using sanitizers satisfying Remark 2.4), and thus the protocol is well-defined and its accuracy is $1-\beta$. Also note that the DP parameter $\delta$ is lower-bounded by $\beta$ because sampling negative noise, however improbable, violates privacy, and therefore the final construction is $(\epsilon,\beta)$-DP.

4.2. Security

Theorem 4.1.

$\mathcal{E}$psolute is $(\beta\cdot m)$-wrong and $(\epsilon,\delta)$-CDP-ODB where the negligible term is $\negl=2\cdot\eta_{2}$.

Proof.

We consider a sequence of views

[TABLE]

${\textsc{View}}_{1}$ is ${\textsc{View}}_{\Pi}\left(\mathcal{D},{q}_{1},\ldots,{q}_{m}\right)$.

${\textsc{View}}_{2}$ is produced only from $\mathcal{DS}\leftarrow{\textsc{A}\left(\textsf{SK}_{1},\ldots,\textsf{SK}_{N}\right)}$. Namely, compute $c_{i}\leftarrow{\textsc{A}\left(\mathcal{DS},{q}_{i}\right)}$ for all $i$ and run ORAM simulator on $\sum_{i}c_{i}$. By ORAM security,

[TABLE]

${\textsc{View}}_{3}$ is produced similarly but $\mathcal{DS}\leftarrow{\textsc{A}\left(\textsf{SK}^{\prime}_{1},\ldots,\textsf{SK}^{\prime}_{N}\right)}$ instead. Note that the $c_{i}$ are simply post-processing on $\mathcal{DS}$ via B so

[TABLE]

${{\textsc{View}}_{4}}={{\textsc{View}}_{\Pi}\left(\mathcal{D}^{\prime},{q}_{1},\ldots,{q}_{m}\right)}$. It follows by ORAM security

[TABLE]

Putting this all together completes the proof. ∎

4.3. Efficiency

For an ORAM with communication efficiency $(a_{1},a_{2})$ and an $(\alpha,\beta)$-differentially private sanitizer, the $\mathcal{E}$psolute communication efficiency is $(a_{1},a_{2}\cdot\alpha)$. The efficiency metrics demonstrate how the total storage or communication volume (the number of stored or transferred bits) changes additively and multiplicatively as the functions of data size $n$ and domain $N$. We therefore have the following corollaries for the efficiency of the system in the cases of approximate and pure differential privacy.

Corollary 4.2.

$\mathcal{E}$psolute is an outsourced database system with storage efficiency $\left(\bigO{1},0\right)$. Depending on the query type, assume it offers the following communication efficiency.

**Range queries: **

$\left(\bigO{\log n},\bigO{2^{\log^{*}N}\log n}\right)$**

**Point queries: **

$\left(\bigO{\log n},\bigO{\log n}\right)$**

*Then, there is a negligible $\delta$ such that $\mathcal{E}$psolute satisfies $(\epsilon,\delta)$-differential privacy for some $\epsilon$.222 Note that the existence of $\epsilon$ in this setting implies that the probability of an adversary breaking the DP guarantees is bounded by it. *

Proof.

By using ORAM, we store only the original data once and hence, we get optimal storage efficiency.

The communication efficiency depends on the upper bound of the error for each sanitizer when $\delta>0$, as described in Section 2.2 and Remark 2.4. The most efficient ORAM protocol to date has $\bigO{\log n}$ communication overhead (see Section 2.3). ∎

Corollary 4.3.

$\mathcal{E}$psolute is an outsourced database system with storage efficiency $\left(\bigO{1},0\right)$. Depending on the query type, assume it offers the following communication efficiency.

**Range queries: **

$\left(\bigO{\log n},\bigO{\log N\log n}\right)$**

**Point queries: **

$\left(\bigO{\log n},\bigO{\log N\log n}\right)$**

Then, $\mathcal{E}$psolute satisfies $\epsilon$-differential privacy for some $\epsilon$.

Proof.

Similarly, we derive the proof by considering the use of ORAM and the upper bound of the error for each sanitizer when $\delta=0$ in Section 2.2. ∎

4.4. Extending to multiple attributes

We will now describe how $\mathcal{E}$psolute supports multiple indexed attributes and what the privacy and performance implications are. The naïve way is to simply duplicate the entire stack of states of $\mathscr{U}$ and $\mathscr{S}$, and during the query use the states whose attribute the query targets. However, $\mathcal{E}$psolute design allows to keep the most expensive part of the state — the ORAM state — shared for all attributes and both types of queries. Specifically, the index $\mathcal{I}$ and DP structure $\mathcal{DS}$ are generated per attribute and query type, while $\mathscr{U}$ and $\mathscr{S}$ ORAM states are generated once. This design is practical since $\mathcal{DS}$ is tiny and index $\mathcal{I}$ is relatively small compared to ORAM states, see Section 6.

We note that in case the indices grow large in number, it is practical to outsource them to the adversarial server using ORAM and download only the ones needed for each query. In terms of privacy, the solution is equivalent to operating different $\mathcal{E}$psolute instances because ORAM hides the values of records and access patterns entirely. Due to Theorem 2.5 for non-disjoint datasets, the total privacy budget of the multi-attribute system will be the sum of individual budgets for each attribute / index.

Next, we choose two DP sanitizers for our system, for point and for range queries, and calculate the $\alpha$ values to make them output positive values with high probability, consistent with Remark 2.4.

4.5. $\mathcal{E}$psolute for point queries

For point queries, we use the LPA method as the sanitizer to ensure pure differential privacy. Specifically, for every histogram bin, we draw noise from the Laplace distribution with mean $\alpha_{p}$ and scale $\lambda=\nicefrac{{1}}{{\epsilon}}$. To satisfy Remark 2.4, we have to set $\alpha_{p}$ such that if values are drawn from ${\textsc{Laplace}\left(\alpha_{p},\nicefrac{{1}}{{\epsilon}}\right)}$ at least as many times as the number of bins $N$, they are all positive with high probability $1-\beta$, for negligible $\beta$.

We can compute the exact minimum required value of $\alpha_{p}$ in order to ensure drawing positive values with high probability by using the CDF of the Laplace distribution. Specifically, $\alpha_{p}$ should be equal to the minimum value that satisfies the following inequality.

[TABLE]

which is equivalent to

[TABLE]

4.6. $\mathcal{E}$psolute for range queries

For range queries, we implement the aggregate tree method as the sanitizer. Specifically, we build a complete $k$-ary tree on the domain, for a given $k$. A leaf node holds the number of records falling into each bin plus some noise. A parent node holds sum of the leaf values in the range covered by this node, plus noise. Every time a query is issued, we find the minimum number of nodes that cover the range, and determine the required number of returned records by summing these node values. Then, we ask the server to retrieve the records in the range, plus to retrieve multiple random records so that the total number of retrieved records matches the required number of returned records.

The noise per node is drawn from the Laplace distribution with mean $\alpha_{h}$ and scale $\lambda=\frac{\log_{k}N}{\epsilon}$. Consistent with Remark 2.4, we determine the mean value $\alpha_{h}$ in order to avoid drawing negative values with high probability. We have to set $\alpha_{h}$ such that if values are drawn from ${\textsc{Laplace}\left(\alpha_{h},\frac{\log_{k}N}{\epsilon}\right)}$ at least as many times as the number of nodes in the tree, they are all positive with high probability $1-\beta$, for negligible $\beta$.

Again, we can compute the exact minimum required value of $\alpha_{h}$ in order to ensure drawing positive values with high probability by using the CDF of the Laplace distribution. Specifically, $\alpha_{h}$ should be equal to the minimum value that satisfies the following inequality.

[TABLE]

which is equivalent to

[TABLE]

where $\mathsf{nodes}=\frac{k^{\ceil{\log_{k}(k-1)+\log_{k}N-1}}-1}{k-1}+N$ is the total number of tree nodes.

5. An efficient Parallel $\mathcal{E}$psolute

While the previously described scheme is a secure and correct CDP-ODB, a single-threaded implementation may be prohibitively slow in practice. To bring the performance closer to real-world requirements, we need to be able to scale the algorithm horizontally. In this section, we describe an upgrade of $\mathcal{E}$psolute — a scalable parallel solution.

We suggest two variants of parallel $\mathcal{E}$psolute protocol. Both of them work by operating $m$ ORAMs and randomly assigning to each of them $\nicefrac{{n}}{{m}}$ database records. For each query, we utilize the index $\mathcal{I}$ to find the required records from the corresponding ORAMs. For each ORAM, we execute a separate thread to retrieve the records. The threads work in parallel and there is no need for locking, since each ORAM works independently from the rest. We present two methods that differ in the way they build and store DP structure $\mathcal{DS}$, and hence the number of ORAM requests they make.

5.1. No-$\gamma$-method: DP structure per ORAM

In $\Pi_{\mathsf{no-}\gamma}$, for each ORAM / subset of the dataset, we build a DP index the same way as described in Section 4. We note that Theorem 2.5 for disjoint datasets applies to this construction: the privacy budget $\epsilon$ for the construction is the largest (least private) among the $\epsilon$’s of the DP indices for each ORAM / subset of the dataset.

The communication efficiency changes because

(i) we essentially add $m$ record subsets in order to answer a query, each having at most $\alpha$ extra random records, and

(ii) each ORAM holds fewer records than before, resulting in a tree of height $\log\frac{n}{m}$.

However, we cannot expect that the records required for each query are equally distributed among the different ORAMs in order to reduce the multiplicative communication cost from $\log n$ to $\frac{\log n}{m}$. Instead, we need to bound the worst case scenario which is represented by the maximum number of records from any ORAM that is required to answer a query. This can be computed as follows.

Let $X_{j}$ be $1$ if a record for answering query $q$ is in a specific ${\textsc{ORAM}}_{j}$, and [math] otherwise. Due to the random assignment of records to ORAMs, $\textnormal{Pr}\left[X_{j}=1\right]=\nicefrac{{1}}{{m}}$. Assume that we need $k_{0}$ records in order to answer query $q$ . The maximum number of records from ${\textsc{ORAM}}_{j}$ in order to answer $q$ is bounded as follows.

[TABLE]

Finally, we need to determine the value of $\gamma$ such that $\exp{\left(-\frac{k_{0}\gamma^{2}}{3m}\right)}$ is smaller than the value $\beta$. Thus, $\gamma=\sqrt{\frac{-3m\log\beta}{k_{0}}}$. The communication efficiency for each query type is described in the following corollary.

Corollary 5.1.

Let $\Pi_{\mathsf{no-}\gamma}$ be an outsourced database system with storage efficiency $\left(\bigO{1},0\right)$. Depending on the query type, $\Pi_{\mathsf{no-}\gamma}$ offers the following communication efficiency.

**Range queries: **

$\left(\bigO{\left(1+\sqrt{\frac{-3m\log\beta}{k_{0}}}\right)\log\frac{n}{m}},\bigO{\frac{\log^{1.5}N}{\epsilon}m\log n}\right)$**

**Point queries: **

$\left(\bigO{\left(1+\sqrt{\frac{-3m\log\beta}{k_{0}}}\right)\log\frac{n}{m}},\bigO{\frac{\log N}{\epsilon}m\log n}\right)$**

Then, $\Pi_{\mathsf{no-}\gamma}$ satisfies $\epsilon$-differential privacy for some $\epsilon$.

In our experiments, we set $m$ as a constant depending on the infrastructure. However, if $m$ is set as $\bigO{\log n}$, the total communication overhead of the construction will still exceed the lower-bound presented in (Larsen et al., 2020).

5.2. $\gamma$-method: shared DP structure

In $\Pi_{\gamma}$, we maintain a single shared DP structure $\mathcal{DS}$. When a query is issued, we must ensure that the number of records retrieved from every ORAM is the same. As such, depending on the required noisy number of records $\tilde{k}_{0}$, we need to retrieve at most $(1+\gamma)\frac{\tilde{k}_{0}}{m}$ records from each ORAM, see Eq. 2, for $\gamma=\sqrt{\frac{-3m\log\beta}{\tilde{k}_{0}}}$. Setting $\tilde{k}_{0}=k_{0}+\frac{\log^{1.5}N}{\epsilon}$ for range queries and $\tilde{k}_{0}=k_{0}+\frac{\log N}{\epsilon}$ for point queries, the communication efficiency is as follows.

Corollary 5.2.

Let $\Pi_{\gamma}$ be an outsourced database system with storage efficiency $\left(\bigO{1},0\right)$. Depending on the query type, $\Pi_{\gamma}$ offers the following communication efficiency.

**Range queries: **

$\left(\bigO{\left(1+\sqrt{\frac{-3m\log\beta}{k_{0}+\frac{\log^{1.5}N}{\epsilon}}}\right)\log\frac{n}{m}\left(1+\frac{\log^{1.5}N}{\epsilon}\right)},0\right)$**

**Point queries: **

$\left(\bigO{\left(1+\sqrt{\frac{-3m\log\beta}{k_{0}+\frac{\log N}{\epsilon}}}\right)\log\frac{n}{m}\left(1+\frac{\log N}{\epsilon}\right)},0\right)$**

Then, $\Pi_{\gamma}$ satisfies $\epsilon$-differential privacy for some $\epsilon$.

$\Pi_{\gamma}$ is depicted in Algorithm 2. There are a few extensions to the subroutines and notation from Algorithm 1. CreateIndex and Lookup now build and query the index which maps a search key to a pair — the record ID and the ORAM ID (1 to $m$) which stores the record. Algorithms 2 to 2 of Algorithm 2 $\Pi_{\mathsf{setup}}$ repeat for each ORAM and operate on the records partitioned for the given ORAM using hash function H on the record ID. A shared DP structure is created with the sanitizer A (Algorithm 2). In Algorithm 2 $\Pi_{\mathsf{query}}$, the total number of ORAM requests is computed once (Algorithm 2). Algorithms 2 to 2 repeat for each ORAM and operate on the subset of records stored in the given ORAM. Note that $\mathscr{U}$ and $\mathscr{S}$ implicitly maintain $m$ ORAM states, and the algorithm uses the $({\textsc{A}},{\textsc{B}})$ sanitizer defined in Section 4.

Note that we guarantee privacy and access pattern protection on a record level. Each ORAM gets accessed at least once (much more than once for a typical query) thus the existence of a particular result record in a particular ORAM is hidden.

5.3. Practical improvements

Here we describe the optimizations aimed at bringing the construction’s performance to the real-world demands.

5.3.1. ORAM request batching

We have noticed that although the entire set of ORAM requests for each query is known in advance, the requests are still executed sequentially. To address this inefficiency, we have designed a way to combine the requests in a batch and reduce the number of network requests to the bare minimum. We have implemented this method over PathORAM, which we use for the $(\eta_{1},\eta_{2})$-ORAM protocol, but the idea applies to most tree-based ORAMs (similar to (Chen et al., 2016)).

Our optimization utilizes the fact that all PathORAM leaf IDs are known in advance and paths in a tree-based storage share the buckets close to the root. The core idea is to read all paths first, processes the requests and and then write all paths back. This way the client makes a single read request, which is executed much faster than many small requests. Requests are then processed in main memory, including re-encryptions. Finally, the client executes the write requests using remapped leaves as a single operation, saving again compared to sequential execution.

This optimization provides up to 8 times performance boost in our experiments. We note that the gains in speed and I/O overhead are achieved at the expense of main memory, which is not an issue given that the memory is released after a batch, and our experiments confirm that. The security guarantees of PathORAM are maintained with this optimization, since the security proof in (Stefanov et al., 2013, Section 3.6) still holds. Randomized encryption, statistically independent remapping of leaves, and stash processing do not change.

5.3.2. Lightweight ORAM servers

We have found in our experiments that naïve increase of the number of CPU cores and gigabytes of RAM does not translate into linear performance improvement after some threshold. Investigating the observation we have found that the $\mathcal{E}$psolute protocol, executing parallel ORAM protocols, is highly intensive with respect to main memory access, cryptographic operations and network usage. The bottleneck is the hardware — we have confirmed that on a single machine the RAM and network are saturated quickly preventing the linear scaling.

To address the problem, we split the user party $\mathscr{U}$ into multiple lightweight machines that are connected locally to each other and reside in a single trust domain (e.g., same data center). Specifically, we maintain a client machine that receives user requests and prepares ORAM read requests, and up to $m$ lightweight ORAM machines, whose only job is to run the ORAM protocols in parallel. See Fig. 2 for the schematic representation of the architecture. We emphasize that $\mathscr{U}$ is still a single party, therefore, the security and correctness guarantees remain valid.

The benefit of this approach is that each of the lightweight machines has its own hardware stack. Communication overhead among $\mathscr{U}$ machines is negligible compared to the one between $\mathscr{U}$ and $\mathscr{S}$. The approach is also flexible: it is possible to use up to $m$ ORAM machines and the machines do not have to be identical. Our experiments show that when the same number of CPU cores and amount of RAM are consumed the efficiency gain is up to 5 times.

6. Experimental Evaluation

We have implemented our solution as a modular client-server application in C++. We open-sourced all components of the software set: PathORAM (Bogatov, 2021d) and B+ tree (Bogatov, 2021a) implementations and the main query executor (Bogatov, 2021b). We provide PathORAM and B+ tree components as C++ libraries to be used in other projects; the code is documented, benchmarked and tested (228 tests covering $100\text{\,}\mathrm{\char 37\relax}\text{/}$ of the code). We have also published our datasets and query sets (Bogatov, 2021c).

For cryptographic primitives, we used OpenSSL library (version 1.1.1i). For symmetric encryption in ORAM we have used AES-CBC algorithm (Dworkin et al., 2001; Dworkin, 2001) with a 256-bits key (i.e., $\eta_{2}=2^{-256}$), for the hash algorithm H used to partition records among ORAMs we have used SHA-256 algorithm (of Standards and Technology, 2015). Aggregate tree fanout $k$ is 16, proven to be optimal in (Qardaji et al., 2013).

We designed our experiments to answer the following questions:

**Question-1: **

How practical is our system compared to the most efficient and most private real-world solutions?

**Question-2: **

How practical is the storage overhead?

**Question-3: **

How different inputs and parameters of the system affect its performance?

**Question-4: **

How well does the system scale?

**Question-5: **

What improvements do our optimizations provide?

**Question-6: **

What is the impact of supporting multiple attributes?

To address **Question-1: ** we have run the default setting using conventional RDBMS (MySQL and PostgreSQL), Linear Scan approach and Shrinkwrap (Bater et al., 2018). To target **Question-2: **, we measured the exact storage used by the client and the server for different data, record and domain sizes. To answer **Question-3: **, we ran a default setting and then varied all parameters and inputs, one at a time. For **Question-4: ** we gradually added vCPUs, ORAM servers and KVS instances and observed the rate of improvement in performance. For **Question-5: ** we have run the default setting with our optimizations toggled. Lastly, for **Question-6: ** we have used two datasets to construct two indices and then queried each of the attributes.

6.1. Data sets

We used two real and one synthetic datasets — California public pay pension database 2019 (Transparent California, 2019) (referred to as “CA employees”), Public Use Microdata Sample from US Census 2018 (U.S. Census Bureau, 2018) (referred to as “PUMS”) and synthetic uniform dataset. We have used salary / wages columns of the real datasets, and the numbers in the uniform set also represent salaries. The NULL and empty values were dropped.

We created three versions of each dataset — $10^{5}$, $10^{6}$ and $10^{7}$ records each. For uniform dataset, we simply generated the target number of entries. For PUMS dataset, we picked the states whose number of records most closely matches the target sizes (Louisiana for $10^{5}$, California for $10^{6}$ and the entire US for $10^{7}$). Uniform dataset was also generated for different domain sizes — number of distinct values for the record. For CA employees dataset, the set contains $260\,277$ records, so we contracted it and expanded in the following way. For contraction we uniformly randomly sampled $10^{5}$ records. For expansion, we computed the histogram of the original dataset and sampled values uniformly within the bins.

Each of the datasets has a number of corresponding query sets. Each query set has a selectivity or range size, and is sampled either uniformly or following the dataset distribution (using its CDF).

6.2. Default setting

The default setting uses the $\Pi_{\gamma}$ from Section 5 and lightweight ORAM machines from Sections 5.3.2 and 2. We choose the $\Pi_{\gamma}$ because it outperforms $\Pi_{\mathsf{no-}\gamma}$ in all experiments (see ****Question-4: **** in Section 6.5). In the setting, there are 64 Redis services (8 services per one Redis server VM), 8 ORAM machines communicating with 8 Redis services each, and the client, which communicates with these 8 ORAM machines. We have empirically found this configuration optimal for the compute nodes and network that we used in the experiments. ORAM and Redis servers run on GCP n1-standard-16 VMs (Ubuntu 18.04), in regions us-east4 and us-east1 respectively. Client machine runs n1-highmem-16 VM in the same region as ORAM machines. The ping time between the regions (i.e. between trusted and untrusted zones) is $12\text{\,}\mathrm{ms}\text{/}$ and the effective bandwidth is $150\text{\,}\mathrm{MB}\text{/}\mathrm{s}$. Ping within a region is negligible.

Default DP parameters are $\epsilon=\ln(2)\approx$0.693$$ and $\beta=2^{-20}$, which are consistent with the other DP applications proposed in the literature (Hsu et al., 2014). Buckets number is set as the largest power of $k=16$ that is no greater than the domain of the dataset $N$.

Default dataset is a uniform dataset of $10^{6}$ records with domain size $10^{4}$, and uniformly sampled queries with selectivity $0.5\text{\,}\mathrm{\char 37\relax}\text{/}$. Default record size is $4\text{\,}\mathrm{KiB}\text{/}$.

6.3. Experiment stages

Each experiment includes running 100 queries such that the overhead is measured from loading query endpoints into memory to receiving the exact and whole query response from all ORAM machines. The output of an experiment is, among other things, the overhead (in milliseconds), the number of real and noisy records fetched and communication volume averaged per query.

6.4. RDBMS, Linear Scan and Shrinkwrap

On top of varying the parameters, we have run similar workloads using alternative mechanisms — extremes representing highest performance or highest privacy. Unless stated otherwise, the client and the server are in the trusted and untrusted regions respectively, with the network configuration as in Section 6.2.

Relational databases

Conventional RDBMS represents the most efficient and least private and secure solution in our set. While MySQL and PostgreSQL offer some encryption options and no differential privacy, for our experiments we turned off security features for maximal performance. We have run queries against MySQL and PostgreSQL varying data and record sizes. We used n1-standard-32 GCP VMs in us-east1 region, running MySQL version 14.14 and PostgreSQL version 10.14.

Linear Scan

Linear scan is a primitive mechanism that keeps all records encrypted on the server then downloads, decrypts and scans the entire database to answer every query. This method is trivially correct, private and secure, albeit not very efficient. There are RDBMS solutions, which, when configured for maximum privacy, exhibit linear scan behavior (e.g., MS-SQL Always Encrypted with Randomized Encryption (Microsoft, 2021) and Oracle Column Transparent Data Encryption (Oracle, 2021)). For a fair comparison we make the linear scan even more efficient by allowing it to download data via parallel threads matching the number of threads and bytes per request to that of our solution. Although linear scan is wasteful in the amount of data it downloads and processes, compared to our solution it has a benefit of not executing an ORAM protocol with its logarithmic overhead and network communication in both directions.

Shrinkwrap

Shrinkwrap (Bater et al., 2018) is a construction that answers federated SQL queries hiding both access pattern and communication volume. Using the EMP toolkit (Wang et al., 2016) and the code Shrinkwrap authors shared with us, we implemented a prototype that only answers range queries. This part of Shrinkwrap amounts to making a scan over the input marking the records satisfying the range, sorting the input, and then revealing the result set plus DP noise to the client. For the latter part we have adapted Shrinkwrap’s Truncated Laplace Mechanism (Bater et al., 2018, Definition 4) to hierarchical method (Qardaji et al., 2013) in order to be able to answer an unbounded number of all possible range queries. We have emulated the outsourced database setting by using two n1-standard-32 servers in different regions ($12\text{\,}\mathrm{ms}\text{/}$ ping and $150\text{\,}\mathrm{MB}\text{/}\mathrm{s}$ bandwidth) executing the algorithm in a circuit model (the faster option per Shrinkwrap experiments) and then revealing the result to the trusted client. We note that although the complexity of a Shrinkwrap query is $\bigO{n\log n}$ due to the sorting step, its functionality is richer as it supports more relational operators, like JOIN, GROUP BY and aggregation. We also note that since MySQL, PostgreSQL and Shrinkwrap are not parallelized within the query, experiments using more CPUs do not yield higher performance.

6.5. Results and Observations

After running the experiments, we have made the following observations. Note that we report results based on the default setting.

• •

$\mathcal{E}$psolute is efficient compared to a strawman approach, RDBMS and Shrinkwrap: it is three orders of magnitude faster than Shrinkwrap, 18 times faster than the scan and only 4–8 times slower than a conventional database. In fact, for different queries, datasets, and record sizes, our system is much faster than the linear scan, as we show next.

• •

$\mathcal{E}$psolute’s client storage requirements are very practical: client size is just below $30\text{\,}\mathrm{MB}\text{/}$ while the size of the offloaded data is over 400 times larger.

• •

$\mathcal{E}$psolute scales predictably with the change in its parameters: data size affects performance logarithmically, record size — linearly, and privacy budget $\epsilon$ — exponentially.

• •

$\mathcal{E}$psolute is scalable: using $\Pi_{\gamma}$ with the lightweight ORAM machines, the increase in the number of threads translates into linear performance boost.

• •

The optimizations proposed in Section 5.3 provide up to an order of magnitude performance gain.

• •

$\mathcal{E}$psolute efficiently supports multiple indexed attributes. The overhead and the client storage increase slightly due to a lower privacy budget and extra local indices.

For the purposes of reproducibility we have put the log traces of all our experiments along with the instructions on how to run them on a publicly available page epsolute.org. Unless stated otherwise, the scale in the figures is linear and the $x$-axis is categorical.

****Question-1: ****: against RDBMS, Linear Scan and Shrinkwrap

The first experiment we have run using $\mathcal{E}$psolute is the default setting in which we observed the query overhead of $840\text{\,}\mathrm{ms}\text{/}$. To put this number in perspective, we compare $\mathcal{E}$psolute to conventional relational databases, the linear scan and Shrinkwrap.

For the default setting, MySQL and PostgreSQL, configured for no privacy and maximum performance, complete in $97\text{\,}\mathrm{ms}\text{/}$ and $220\text{\,}\mathrm{ms}\text{/}$ respectively, which is just 8 to 4 times faster than $\mathcal{E}$psolute, see Fig. 3. Conventional RDBMS uses efficient indices (B+ trees) to locate requested records and sends them over without noise and encryption, and it does so using less hardware resources. In our experiments RDBMS performance is linearly correlated with the result and record sizes.

Linear scan experiments demonstrate the practicality of $\mathcal{E}$psolute compared to a trivial “download everything every time” approach, see Fig. 4. Linear scan’s overhead is $\bigO{n}$ regardless of the queries, while $\mathcal{E}$psolute’s overhead is $\bigO{\log{n}}$ times the result size. According to our experiments, $\mathcal{E}$psolute eclipses the linear scan at $4\text{\,}\mathrm{KiB}\text{/}$, 64 threads and only ten thousand records (both mechanisms complete in about $120\text{\,}\mathrm{ms}\text{/}$). For a default setting (at a million records), the difference is 18 times, see Fig. 4.

Because Shrinkwrap sorts the input obliviously in a circuit model, it incurs $\bigO{n\log n}$ comparisons, each resulting in multiple circuit gates, which is much more expensive than the linear scan. Unlike linear scan, however, Shrinkwrap does not require much client memory as the client merely coordinates the query. While Shrinkwrap supports richer set of relational operators, for range queries alone $\mathcal{E}$psolute is three orders of magnitude faster.

****Question-2: ****: storage

While $\mathcal{E}$psolute storage efficiency is near-optimal $\left(\bigO{1},0\right)$, it is important to observe the absolute values. Index $\mathcal{I}$ is implemented as a B+ tree with fanout 200 and occupancy $70\text{\,}\mathrm{\char 37\relax}\text{/}$, and its size, therefore, is roughly $5.7n$ bytes. Most of the ORAM client storage is the PathORAM stash with its size chosen in a way to bound failure probability to about $\eta_{1}=2^{-32}$ (see (Stefanov et al., 2013, Theorem 1)). In Table 1, we present $\mathcal{E}$psolute storage usage for the parameters that affect it — data, record and domain sizes. We measured the sizes of the index $\mathcal{I}$, DP structure $\mathcal{DS}$, and ORAM client and server states. Our observations are:

(i) index size expectedly grows only with the data size,

(ii) $\mathcal{DS}$is negligibly small in practice,

(iii) small $\mathcal{I}$ and $\mathcal{DS}$ sizes imply the efficiency of supporting multiple indexed attributes,

(iv) $\mathscr{S}$to $\mathscr{U}$ storage size ratio varies from 85 in the smallest setting to more than $2\,000$ in the largest, and

(v) one can trade client storage for ORAM failure probability.

We conclude that the storage requirements of $\mathcal{E}$psolute are practical.

****Question-3: ****: varying parameters

To measure and understand the impact of configuration parameters on the performance of our solution we have varied $\epsilon$, record size, data size $n$, domain size $N$, selectivities, as well as data and query distributions. The relation that is persistent throughout the experiments is that for given data and record sizes, the performance (the time to completely execute a query) is strictly proportional to the total number of records, fake and real, that are being accessed per query. Each record access goes through the ORAM protocol, which, in turn, downloads, re-encrypts and uploads $\bigO{\log{n}}$ blocks. These accesses contribute the most to the overhead and all other stages (e.g., traversing index or aggregate tree) are negligible.

Privacy budget $\epsilon$ and its effect

We have run the default setting for $\epsilon=\{0.1,\allowbreak 0.5,\allowbreak\ln{2},\allowbreak 1.0,\allowbreak\ln{3}\}$. $\epsilon$ strictly contributes to the amount of noise, which grows exponentially as $\epsilon$ decreases, see Fig. 5, observe sharp drop. As visualized on Fig. 6, at high $\epsilon$ values the noise contributes a fraction of total overhead, while at low values the noise dominates the overhead entirely.

Selectivity

We have ranged the selectivity from $0.1\text{\,}\mathrm{\char 37\relax}\text{/}$ to $2\text{\,}\mathrm{\char 37\relax}\text{/}$ of the total number of records, see Fig. 7. Overhead expectedly grows with the result size. For smaller queries, and thus for lower overhead, the relation is positive, but not strictly proportional. This phenomena, observed for the experiments with low resulting per-query time, is explained by the variance among parallel threads. During each query the work is parallelized over $m$ ORAMs and the query is completed when the last thread finishes. The problem, in distributed systems known as “the curse of the last reducer” (Suri and Vassilvitskii, 2011), is when one thread takes disproportionally long to finish. In our case, we run 64 threads in default setting, and the delay is usually caused by a variety of factors — blocking I/O, network delay or something else running on a shared vCPU. This effect is noticeable when a single thread does relatively little work and small disruptions actually matter; the effect is negligible for large queries.

Record, data and domain sizes

We have tried $1\text{\,}\mathrm{KiB}\text{/}$, $4\text{\,}\mathrm{KiB}\text{/}$ and $16\text{\,}\mathrm{KiB}\text{/}$ records, see Fig. 8. Trivially, the elapsed time is directly proportional to the record size.

We set $n$ to $10^{5}$, $10^{6}$ and $10^{7}$, see Fig. 9. The observed correlation of overhead against the data size is positive but non-linear, 10 times increment in $n$ results in less than 10 times increase in time. This is explained by the ORAM overhead — when $n$ changes, the ORAM storage gets bigger and its overhead is logarithmic.

For synthetic datasets we have set $N$ to $100$, $10^{4}$ and $10^{6}$, see Fig. 10. The results for domain size correlation are more interesting: low and high values deliver worse performance than the middle value. Small domain for a large data set means that a query often results in a high number of real records, which implies significant latency regardless of noise parameters. A sparse dataset, on the other hand, means that for a given selectivity wider domain is covered per query, resulting in more nodes in the aggregate tree contributing to the total noise value.

Data and query distributions

Our solution performs best on the uniform data and uniform ranges, see Figs. 11 and 12. Once a skew of any kind is introduced, there appear sparse and dense regions that contribute more overhead than uniform regions. Sparse regions span over wider range for a given selectivity, which results in more noise. Dense regions are likely to include more records for a given range size, which again results in more fetched records. Both real datasets are heavily skewed towards smaller values as few people have ultra-high salaries.

****Question-4: ****: scalability

Horizontal scaling is a necessity for a practical system, this is the motivation for the parallelization in the first place. Ideally, performance should improve proportionally to the parallelization factor, number of ORAMs in our case, $m$.

For scalability experiments we run the default setting for both $\Pi_{\mathsf{no-}\gamma}$ and $\Pi_{\gamma}$ (no-$\gamma$-method and $\gamma$-method respectively) varying the number of ORAMs $m$, from 8 to 96 (maximum vCPUs on a GCP VM). The results are visualized on Fig. 13. We report two positive observations:

(i) the $\gamma$-method provides substantially better performance and storage efficiency, and

(ii) when using this method the system scales linearly with the number of ORAMs.

($m=96$ is a special case because some ORAMs had to share a single KVS.)

****Question-5: ****: optimizations benefits

Table 2 demonstrates the boosts our improvements provide; when combined, the speedup is up to an order of magnitude.

ORAM request batching (Section 5.3.1) makes the biggest difference. We have run the default setting with and without the batching. The overhead is substantially smaller because far fewer I/O requests are being made, which implies benefits across the full stack: download, re-encryption and upload.

Using lightweight ORAM machines (Section 5.3.2) makes a difference when scaling. In the default setting, 64 parallel threads quickly saturate the memory access and network channel, while spreading computation among nodes removes the bottleneck.

****Question-6: ****: multiple attributes

$\mathcal{E}$psolute supports multiple indexed attributes. In Section 4.4 we described that the performance implications amount to having an index $\mathcal{I}$ and a DP structure $\mathcal{DS}$ per attribute and sharing the privacy budget $\epsilon$ among all attributes. As shown in Table 1, $\mathcal{I}$ and $\mathcal{DS}$ are the smallest components of the client storage. To observe the query performance impact, we have used the default dataset with domains $10^{4}$ and $10^{6}$ as indexed attributes A and B respectively. We ran queries against only A, only B and against both attributes in alternating fashion. Each of the attributes used $\epsilon=\frac{\ln{2}}{2}$ to match the default privacy budget of $\ln(2)$.

Fig. 14 demonstrates the query overhead of supporting multiple attributes. The principal observation is that the overhead increases only slightly due to a lower privacy budget. The client storage went up by just $9\text{\,}\mathrm{MB}\text{/}$, and still constitutes only $3.3\text{\,}\mathrm{\char 37\relax}\text{/}$ of the server storage, which is not affected by the number of indexed attributes.

7. Conclusion and Future Work

In this paper, we present a system called $\mathcal{E}$psolute that can be used to store and retrieve encrypted records in the cloud while providing strong and provable security guarantees, and that exhibits excellent query performance for range and point queries. We use an optimized Oblivious RAM protocol that has been parallelized together with very efficient Differentially Private sanitizers that hide both the access patterns and the exact communication volume sizes and can withstand advanced attacks that have been recently developed. We provide a prototype of the system and present an extensive evaluation over very large and diverse datasets and workloads that show excellent performance for the given security guarantees.

In our future work, we plan to investigate methods to extend our approaches to use a trusted execution environment (TEE), like SGX, in order to improve the performance even further. We will also explore a multi-user setting without the need for a shared stateful client, and enabling dynamic workloads with insertions and updates. We will also consider how adaptive and non-adaptive security models would change in the case of dynamic environments. One would presumably also require DP of the server’s view in this setting. Lastly, we plan to explore other relational operations like JOIN and GROUP BY.

Acknowledgements.

We thank anonymous reviewers and Arkady Yerukhimovich for valuable feedback. We also thank Daria Bogatova for devising the name $\mathcal{E}$psolute and helping with the plots, diagrams and writing. Finally, we thank Johes Bater for sharing Shrinkwrap code and reviewing the prototype. Kobbi Nissim was supported by NSF Grant No. 2001041, “Rethinking Access Pattern Privacy: From Theory to Practice”. Dmytro Bogatov and George Kollios were supported by NSF CNS-2001075 Award.