Secure selections on encrypted multi-writer streams

TL;DR

This paper introduces a new cryptographic scheme called Secure Selective Stream (SSS) that enables secure, efficient, multi-writer encrypted data streams with fine-grained access control, addressing limitations of single-writer models.

Contribution

The paper presents the first public-key scheme for multi-writer encrypted streams with size-efficient ciphertexts and access policies, along with security proofs and a C++ implementation.

Findings

Ciphertexts have size proportional to data size

Encryption and decryption are linear in data item size

Scheme is proven secure under bilinear hardness assumptions

Abstract

Performing searches over encrypted data is a very current and active area. Several efficient solutions have been provided for the single-writer scenario in which all sensitive data originates with one party (the Data Owner) that encrypts it and uploads it to a public repository. Subsequently the Data Owner (or authorized clients, the Query Sources) accesses the encrypted data through a Query Processor which has direct access to the public encrypted repository. Motivated by the recent trend in pervasive data collection, we depart from this model and consider a multi-writer scenario in which data originates with several and mutually untrusted parties. In this new scenario the Data Owner provides public parameters so that each item of the generated data stream can be put into an encrypted stream; moreover, the Data Owner keeps some related secret information needed to generate tokens so that different subscribers can access different subsets of the encrypted stream in clear, as specified by corresponding access policies. We propose a new public-key scheme, Secure Selective Stream (SSS), built upon an Amortized Encryption Scheme (AOE), that can be used to encrypt each item in the stream so that the ciphertexts have size proportional to the un-encrypted data; moreover, encryption and decryption take time linear in the data item size. We provide constructions for SSS and AOE. We provide a game-based and an indistinguishability-based security notions for SSS, we prove that the SSS scheme is game-base secure given that the AOE scheme is game-based secure as well. We prove that AOE is secure under hardness assumptions in the bilinear setting. We provide an implementation in C++ all the basic operations in our multi-writer scenario using one round of communication.

Figures

Equations

$${\mathbb{PP}}_{\mathcal{Q}}(M_1,\dots ,M_n):=\underset{j=1}{\overset{\nu }{\bigwedge }}(M_{i_j}=m_j).$$

$${\mathbb{PM}}_{\mathcal{Q}}(M_1,\dots ,M_n,i):=(i=d)\wedge \underset{j=1}{\overset{\nu }{\bigwedge }}(M_{i_j}=m_j).$$

$$\{{\mathsf{View}}^{\mathsf{C}}(\lambda ,\mathcal{I})\}\text{ and }\{\mathsf{Sim}(1^{\lambda },\mathcal{L}(\mathsf{C},\mathcal{I}))\}$$

$$\left|p_{\mathcal{A}}^0(\lambda )-p_{\mathcal{A}}^1(\lambda )\right|\le \mathtt{negl}(\lambda ).$$

$$\left|p_{\mathcal{A}}^i(\lambda ,\mathcal{I})-p_{\mathcal{A}}^{i+1}(\lambda ,\mathcal{I})\right|\ge 1/\mathtt{poly}(\lambda ),$$

$$({\mathtt{Pol}}_i=\star )\vee ({\mathtt{Pol}}_i={\mathtt{Row}}_i)$$

$$\left|p^{\mathcal{A}}(\lambda ,n,u,v)-\frac{1}{2}\right|$$

$$\mathsf{SSS}=(\mathsf{SSS}.\mathsf{Init},\mathsf{SSS}.\mathsf{AuthorizeSel},\mathsf{SSS}.\mathsf{AuthorizeDec},\mathsf{SSS}.\mathsf{Encrypt},\mathsf{SSS}.\mathsf{Select},\mathsf{SSS}.\mathsf{Decrypt})$$

$$S_0=(-t_1,\dots ,-t_n,\sum _{i=1}^n{t}_i{\mathtt{Pol}}_i)$$

$$X_0=({\mathtt{Row}}_1,\dots ,{\mathtt{Row}}_n,1)$$

$$X_i=(1,i)\text{,for }i=1,\dots ,n.$$

$${\mathsf{Stream}}^0$$

$${\mathsf{Stream}}^1$$

$$X_0^0=({\mathtt{Row}}_{1,1}^0,\dots ,{\mathtt{Row}}_{1,n}^0,1)$$

$$X_0^1=({\mathtt{Row}}_{1,1}^1,\dots ,{\mathtt{Row}}_{1,n}^1,1)$$

$${\mathtt{Pol}}_1{\mathtt{Row}}_1+\dots +{\mathtt{Pol}}_n{\mathtt{Row}}_n-\sum _{i=1}^n{\mathtt{Pol}}_i=0,$$

$${\mathtt{Pol}}_1{\mathtt{Row}}_1+\dots +{\mathtt{Pol}}_n{\mathtt{Row}}_n-\sum _{i=1}^n{\mathtt{Pol}}_i\ne 0,$$

$$\mathtt{msk}=\Bigl{(}(\alpha_{1},\beta_{1}),(\alpha_{2},\beta_{2}),(\omega,g,g_{2}),(\mathtt{bmsk}_{j}^{1},\mathtt{bmsk}_{j}^{2})_{j=0}^{n}\Bigr{)},$$

$${\mathtt{bmpk}}_0^1$$

$${\mathtt{bmpk}}_0^2$$

$${\mathtt{bmpk}}_j^1$$

$${\mathtt{bmpk}}_j^2$$

$$\mathtt{mpk}=\Bigl{(}\Lambda,\Omega,\left(\mathtt{bmpk}_{j}^{1},\mathtt{bmpk}_{j}^{2}\right)_{j=0}^{n}\Bigr{)}.$$

$$A_j=g^{q_j}{B}_j={\Omega }^{l_j}{C}_j={\Lambda }^{q_j}\cdot M_j$$

$$D_{i,1,j}$$

$$E_{i,1,j}$$

$$D_{i,2,j}$$

$$E_{i,2,j}$$

$$K_{i,1}=g^{{\beta }_1\cdot r_{i,1}}\cdot g^{{\lambda }_1\cdot {\theta }_{i,1}\cdot s_i}$$

$$K_{i,2}=g^{{\beta }_2\cdot r_{i,2}}\cdot g^{{\lambda }_2\cdot {\theta }_{i,2}\cdot s_i}$$

$$F=g_2\cdot \prod _{i=1}^f{K}_{i,1}^{-{\gamma }_{i,1}}\cdot L_{i,1}^{-{\delta }_{i,1}}\cdot K_{i,2}^{-{\gamma }_{i,2}}\cdot L_{i,2}^{-{\delta }_{i,2}}$$

$$H=g^{{\sum }_{i=1}^f{r}_{i,1}+r_{i,2}}.$$

Full text

We propose security model for this problem that we call Secure Selective Stream (SSS) and give a secure construction for it based on hard problems in Pairing-Based Cryptography. The cryptographic core of our construction is a new primitive, Amortized Encryption Scheme (AOE), that is crucial for the efficiency of the resulting SSS.

1. 1 Introduction

2. 2 Secure Selective Stream

3. 2.1 Syntax

4. 2.2 Simulation-based security

5. 2.3 Game-based security

6. 2.4 Invertible policies

7. 2.5 Simulation-based security implies game-based security for invertible policies

8. 2.6 Game-based security implies simulation-based security for invertible policies

9. 3 Constructing $\mathsf{SSS}$ from $\mathsf{AOE}$

10. 3.1 Amortized Orthogonality Encryption

11. 3.2 Security game for $\mathsf{AOE}$

12. 3.3 Constructing $\mathsf{SSS}$

13. 3.4 Security of the $\mathsf{SSS}$ construction

14. 3.5 $\mathbb{CONJ}$ is invertible

15. 4 Constructing $\mathsf{AOE}$

16. 4.1 Correctness of the construction

17. 4.2 Security of the construction

18. 4.2.1 Simulators

19. 5 Experimental evaluation

20. 6 Conclusions

1 Introduction

As computing devices become more and more pervasive, our means to collect data become more and more distributed and allow to have data on phenomena that occur in a widespread area. Reality mining is defined as “the collection of machine-sensed environmental data pertaining to human social behavior [16]” and has changed the way human interactions are studied. A similar phenomenon is taking place in the health care domain in which epidemiological data can be collected at a countrywide level by hospitals and private practices. The ability to create large data sets poses serious privacy concerns and requires extra care. Encryption is the obvious tool to preserve data confidentiality and recent advances in Cryptography allow the owner of the data to perform (or to enable third parties to perform) specific queries on encrypted data. Even though searchable encryption [8] has been introduced as a public key primitive, all systems in the literature providing query capabilities over encrypted data (most notably CryptDB [35]) have considered a scenario in which the data originates with one user and the same user (or some authorized third parties) performs searches on the encrypted data. We are interested in the more challenging scenario in which several data sources generate data managed by a data owner and the data owner enables several query sources to view parts of the data according to its own access policies (which may vary depending on the query source). The query sources use query processors that have direct access to the stream of encrypted data generated by the data sources and select data to which access is granted. Thus, roughly speaking, we are interested in a multi-writer, and thus * public-key*, setting whereas previous proposals have considered a single-writer, and thus * private-key*, setting.

Secure Selective Streams. We formalize the scenario we just introduced by the notion of a Secure Selective Stream ($\mathsf{SSS}$) scheme. More precisely, we have four different types of actors: one Data Owner, multiple Data Sources, multiple Query Sources, multiple Query Processors (see Figure 1). The Data Owner (the DO, in short) manages access policies to the data originating from several Data Sources (the DSs, in short) and collected in encrypted form on a possibly untrusted server. The Query Processors (the QPs, in short) have direct physical access to the encrypted data and perform the queries on behalf of the Query Sources (the QSs, in short). We consider a threat model in which the Data Owner DO is the only fully trusted party. The Data Sources (the DSs) are trusted to upload significant data but they should not be able to read the data uploaded by other DSs. The Query Processors QPs are honest-but-curious and it is expected to execute the prescribed code. The Query Sources (the QSs) should be able to learn only the data they have been authorized to read by the DO. This requirement extends to coalitions of QSs: a coalition can only learn the union of the data they are authorized to read and nothing else. Of course, with the help of the QPs, they could learn, for example, which data items were selected by both queries they have been authorized to issue but, still, no extra data item is revealed. We also protect the QSs from the QPs by not letting the QPs read the result of the queries issued by the QSs and we want the QPs not to learn the exact number of selected data items. In other words, the QPs and DS only learn data-access and search patterns and no explicit data, except the authorized data, is disclosed. The mechanism by which the DO decides which query is a QS authorized to issue is not considered in this paper. We stress also that, even though the DSs can encrypt data, they do not have the ability to authorize searches. In other words the ability to write (to encrypt) data is decoupled from the ability to query (to decrypt) data thus making our scenario inherently a public-key one. We look at the case in which the data streams are collected as data items with same number of cells. We aim to support access that correspond to conjunctive queries composed by equality-based predicates. That is, each query asks to see the content of some of the cells of the data items that satisfy the search predicates.

Our approach. The recent advances in Functional Encryption [11] provide a straightforward secure implementation of our scenario. More precisely, the DO publishes the public key of a Functional Encryption scheme to be used by a DSs to encrypt the data items. The DO uses the associated secret key to compute the token needed to perform the query the specific QS is authorized to perform. A QP then simply applies the token to the encrypted data and returns the result. This approach has the advantage of supporting any query that can be expressed by a small (polynomial) circuit [17, 38, 2] (and, actually, even more [3]). Unfortunately, these are to be seen more as feasibility results and unlikely to be, at this stage, of direct use in a practical system. We are less ambitious with respect to the range of queries supported but we do insist on an efficient and practical solution with clear and provable security guarantees. Specifically, we consider the case in which the DSs generate a stream of rows with the same number of cells and we wish to support queries that select one specified cell from all rows that satisfy an access policy that can be expressed as a conjunction of equalities between cells and constants. Even for the set of access policies (or, equivalently, queries) of our interest, the state of the art in public-key functional encryption does not offer an adequate solution.

Hidden Vector Encryption (HVE, see  [12, 20, 15]) seems to perfectly suit our setting. Roughly speaking, HVE allows to encrypt plaintext $M$ with respect to attribute vector $X=(X_{1},\ldots,X_{n})$ with components taken from an attribute space $\cal X$. The owner of the master secret key can generate tokens associated with vectors $Y=(Y_{1},\ldots,Y_{n})$ in which each component is either a “don’t care symbol” $\star$ or an element of $\cal X$. A token associated with $Y$ can be used to decrypt all ciphertexts whose attribute vector $X$ coincides with $Y$ in all components that are not $\star$. HVE can be used to implement our scenario in a straightforward way: the DS encrypts each cell of the table by using the values in the other columns of the same row as attributes and the value in the cell itself as plaintext. Then, as it easily seen, every query that we wish to support directly maps to a vector $Y$ and thus a QS requests the appropriate token to the DO. A QP applies the token to each encrypted cell and returns the ones that are decrypted correctly. The simple implementation described above is not practical, though. First of all, the secret key of all the known implementations of HVE need $O(n\cdot\log|{\cal X}|)$ group elements each of size proportional to the security parameter. More importantly, the ciphertext of one cell has length proportional to $n\cdot\log|{\cal X}|$ where $n$ is the number of columns in a row. This implies that a row with $n$ columns, once encrypted, will have length $\Omega(n^{2})$, clearly impractical. This second problem seems inherent since, obviously, a ciphertext must be at least as long as its attributes. Our main technical contribution is based on the observation that cells of the same row are encrypted using the same attributes and thus we could hope to have an amortized encryption scheme that can be used to reduce the cumulative length of the ciphertexts of the cells of a row.

Amortized Orthogonality Encryption. In order to get around the efficiency drawback of HVE, we introduce the notion of an Amortized Orthogonality Encryption scheme (an $\mathsf{AOE}$ scheme, in short) and provide a construction for it. Before explaining how $\mathsf{AOE}$ can be used to reach our goal of an efficient and secure $\mathsf{SSS}$, we give a rough description of $\mathsf{AOE}$. In a regular (i.e., non-amortized) Orthogonality Encryption scheme, ciphertexts and tokens are associated with attribute vectors of the same length over some finite field. A token associated with vector $Y$ can be used to decrypt all ciphertexts whose associated attribute vector $X$ is orthogonal to $Y$. Orthogonality Encryption can be used to implement HVE as well as disjunctive queries that will be useful in our scenario.111Orthogonality Encryption has been introduced by [24] with the name of “Inner Product Encryption.” Recently, the term “Inner Product” has been also used by [1] in connection with a different albeit related concept. We choose to use the term “Orthogonality Encryption” as it better reflects the nature of the concept we intend to use and avoids any misunderstanding as to which of the two concepts, the one of [24] or the one of [1], we are using. An Amortized Orthoganility Encryption scheme has the extra feature that the encryption algorithm takes as input $n$ plaintexts $M_{1},\ldots,M_{n}$ and $n+1$ attribute vectors $X_{0},X_{1},\ldots,X_{n}$, where $X_{1},\ldots,X_{n}$ have the same length $k$ and $X_{0}$ a possibly different length $l$, and produces a cumulative ciphertext $\mathtt{eRow}$ in which plaintext $M_{i}$ is encrypted with respect to attribute vector $(X_{0},X_{i})$ of length $l+k$ obtained by concatenating $X_{0}$ and $X_{i}$. The cumulative ciphertext has total length $\Theta(l+n\cdot k)$, which is asymptotically optimal as it is proportional to the total length of the attributes. The owner of the master secret key $\mathtt{msk}$ for an $\mathsf{AOE}$ can release two types of tokens: predicate-only tokens, the P-tokens, and message tokens, the M-tokens. A P-token is associated with a vector $Y_{0}$ of length $l$ and it can be used to check whether the attribute vector $X_{0}$ associated with a cumulative ciphertext $\mathtt{eRow}$ is orthogonal to $Y_{0}$. Notice that no plaintext is obtained by applying a P-token to a $\mathtt{eRow}$. An M-token instead is associated with a vector $Y$ of length $l+k$ and, when applied to a cumulative ciphertext, can be used to obtain message $M_{i}$ only if the corresponding attribute vector $(X_{0},X_{i})$ is orthogonal to $Y$.

Efficiency. As we have stated above, the cumulative ciphertext has total length $\Theta(l+n\cdot k)$. When implemented in a bilinear settings (like all the known implementations of HVE and Orthogonality or, as it is called in the literature, IPE), the length of the ciphertext corresponds to the number of group elements. In implementing our scenario for data organized in rows with $n$ columns, we will use $\mathsf{AOE}$ with $k:=2$ and $l:=2n+1$ thus yielding, for each row, a cumulative ciphertext with $\Theta(n)$ group elements as opposed to $\Theta(n^{2})$ group elements needed by Orthogonality. The saving is not only in space but also in the time needed to perform encryption and decryption as they take time linear in the number of group elements. Therefore, using $\mathsf{AOE}$ guarantees that encryption takes time linear in the number of columns whereas Orthogonality would use quadratic time (see also Section 5).

Implementing $\mathsf{SSS}$ using $\mathsf{AOE}$. We use $\mathsf{AOE}$ to provide a secure implementation of $\mathsf{SSS}$  according to the following steps (refer to Figure 1): (i) The DO generates a pair of public and secret master key $(\mathtt{mpk},\mathtt{msk})$ and distributes the $\mathtt{mpk}$ to all DSs. (ii) A DS adds a new data item consisting of cells $M_{1},\ldots,M_{n}$ to the encrypted stream by performing the following steps. Each $M_{i}$ is encrypted by using the public master key $\mathtt{mpk}$ and a set of attributes that depends on the actual values contained in the cells and on the index $i$ of cell $M_{i}$. We point out that the resulting values of $l$ and $k$ will be such that a cumulative ciphertext of a data item with $n$ cells has length $\Theta(n)$ which is asymptotically optimal (see the discussion in Section 5).

(iii) An access policy $\cal Q$ is specified by the column $d$ to be selected and by a sequence of pairs attribute and value $(i_{j},m_{j})_{j=1}^{\nu}$, for some $\nu\leq n$. The DO, upon receiving the request for the token for ${\cal Q}$ from a QS, computes a P-token $\mathtt{p}\mathtt{Tok}$ and a M-token $\mathtt{m}\mathtt{Tok}$. The P-token checks if the attributes derived from the common attributes $M_{1},\ldots,M_{n}$ of the cells of a data item satisfy the predicate

[TABLE]

The M-token instead is such that it can be used to decrypt all cells in the $d$-th position of data items that satisfy the predicate

[TABLE]

We postpone the discussion on how $\mathtt{m}\mathtt{Tok}$ and $\mathtt{p}\mathtt{Tok}$ can be computed by means of an $\mathsf{AOE}$. DO passes $\mathtt{m}\mathtt{Tok}$ and $\mathtt{p}\mathtt{Tok}$ to QS that keeps the $\mathtt{m}\mathtt{Tok}$ for himself and passes the $\mathtt{p}\mathtt{Tok}$ to a QP. (iv) The QP uses $\mathtt{p}\mathtt{Tok}$ to select rows from the encrypted table to be passed to the QS. (v) The QS applies $\mathtt{m}\mathtt{Tok}$ to each of the rows received from the QP. We remark that QP does not learn which cell the QS is interested in nor its content.

We have implemented the construction in C/C++ showing the feasibility and efficiency of our approach. We present our implementation in Section 5.

Orthogonality supports $\mathbb{PP}$ and $\mathbb{PM}$. Let us now briefly explain how orthogonality can be used to implement encryption that supports tokens for $\mathbb{PP}$ and $\mathbb{PM}$. Inner product computation can be used to encrypt data so that one can issue tokens to check polynomial identities. Specifically, observe that evaluating a $d$-degree multivariate polynomial $P(x_{1},\ldots,x_{m})$ in a $m$-dimensional point $(r_{1},\ldots,r_{m})$ corresponds to an inner product computation between the vector $Y$ of the coefficients of the polynomial $P$ and the $O(m^{d})$ monomials $r_{1}^{d_{1}}\cdot r_{2}^{d_{2}}\cdots\cdot r_{m}^{d_{m}}$. In our case, the arithmetization of predicate $\mathbb{PP}$ gives a polynomial of degree $2$ with with $O(n)$ non-zero coefficients ($n$ is the number of cells in a row) whereas for $\mathbb{PM}$ we obtain a polynomial of degree $1$ and thus with $O(n)$ non-zero coefficients. Therefore, we need $\mathsf{AOE}$ with $l=O(n)$ and $k=O(1)$ and this keeps the size of the cumulative ciphertext corresponding to a row with $n$ cells $O(n)$. As we shall see in Section 5 the constants hidden by the asymptotic notation are very small and the resulting implementation is quite practical.

Related works. All the major commercial RDBMS releases provide functionalities to encrypt the data they store (see, for example, [31]). However, these solutions are based on data-at-rest encryption, thus limiting the functionalities over encrypted data, that have to be decrypted by the server before queries can be processed. Therefore this type of solutions is not suited for our scenario. More limited support for secure operations is provided by systems that manage data streams such as pub/sub systems. The advent of fast networks and cheap online storage has made viable the management of encrypted data at application-level. One of the first works to present the paradigm database-as-a-service is [18]. In [4] a database architecture based on a trusted hardware cryptographic module is presented. In [19], a prototype is presented that executes queries over an encrypted relational database in a multiple client setting. Their approach offers protection to non-compromised clients against a passive attacker that has access to all the data of a fraction of clients. Symmetric Searchable Encryption (SSE) provides a way to perform keyword searches on encrypted data. Here the Data Owner pre-processes and encrypts the data so to allow the Query Processor to perform queries efficiently. The first construction giving sublinear time was presented in [14] and extended to conjunctive and general Boolean searches by [13]. Both constructions are single-writer (only the DO can encrypt) and single-reader (only the DO can perform searches). This was extended to single-writer and multi-reader (i.e., allowing multiple independent QSs) by [21]. Our system can be seen as the first proposal allowing for multiple writers (DSs) and readers (QSs). Having a single trusted writer allows for a centralized and optimized pre-processing of the data which is not possible in our multi-writer scenario. On the other hand, most of the proposals based on SSE are static in the sense that it is very expensive to add new data (unless only single-keyword searches are supported [22] or extra information is leaked [13]). In contrast, in our proposal any Data Source DS can efficiently add new data to the table at the cost of an encryption and without the help of the DO. Different advanced cryptographic primitives have been employed in the design and construction of systems supporting queries over encrypted tables. CryptDB [35, 34] is the prime example of this line of research. CryptDB is in the single-writer model and leaks statistical information on the whole queried column (that is, not limited to the matching rows) and this can be exploited by attacks that can reveal significant information such as repeated values in the column (see [28, 36]). These attacks leverage on CryptDB’s use of deterministic and property-preserving encryption (PPE) that are instrumental to support advanced queries. Our proposal does not use any of these cryptographic primitives and thus these attacks are irrelevant. Moreover, AOE, unlike PPE, does not have any inherent leakage on the encrypted plaintext (besides some trivial information such as plaintext length). The work of [23] provided a new construction that does not make use of property-preserving encryption and that supports a large class of SQL queries. More recently, Boelter et al. [6, 33] have presented a single-writer system for querying encrypted data, called Arx, that supports range queries, in addition to our set of queries. The technical core of the system is a construction of a secure scheme for performing range queries on a key-value table [6]. Mylar [39] is another recently proposed system that uses advanced encryption techniques to support web applications that store encrypted data on a server, allows for keyword searches over it, and the sharing of data encrypted using different keys. The system relies on multi-key searchable encryption [41] that allows for the transformation of a keyword search token from one user to another. As shown by Grubbs et al. [40], Mylar can be attacked by compromising the server allowing the attacker to retrieve the plaintext keyword used for a search and discover which documents contain it. Also, the key transformation technique is transitive, and this can create additional security problems. These attacks are not relevant for our proposal as we rely on different cryptographic primitives. Regarding systems managing data streams, such as publish-subscribe systems, overviews of the challenges faced by cryptographic solutions are in [42] and [43]. There is a growing body of literature applying attribute-based and proxy re-encryption based techniques in pub-sub architectures. See [45], [46] for significant examples of pub-sub systems allowing that collect and distributed encrypted data streams.

In contrast to the works described above, our work is more cryptographic (and less system oriented) in nature and proposes a new efficient cryptographic primitive with a direct application to a concrete application scenario that has not been implemented by existing systems. A first version of the $\mathsf{AOE}$scheme is presented in [47], where it is deployed in order to provide secure queries over an encrypted repository. In the public-key domain, we mention the first proposal of Searchable Encryption [8] supporting very simple queries then extended to conjunctive queries in [12]. Our construction of $\mathsf{AOE}$ is inspired by the constructions of public-key encryption schemes supporting the orthogonality predicate, a concept introduced by [24] along with the first secure construction based on bilinear groups of composite order. A construction based on bilinear groups of prime order is given in [32] and it constitutes the starting block of our $\mathsf{AOE}$. Constructions of the orthogonality encryption with adaptive security were given in [25, 29]. The issue of short ciphertexts and keys for the orthogonality encryption scheme was studied in [30] that gave a construction with short ciphertexts for the orthogonality encryption but no security guarantee was offered for the attributes (in other words, [30] gives an attribute-based orthogonality encryption scheme). Note that in our setting this is crucial as the attribute of a cell are the values of the cells in the same row and therefore they must be kept secret. The problem of query privacy has also been studied. For the specific case of orthogonality encryption, an elegant construction that guarantees security of the query has been given in [37]. In general, indistinguishability-based query privacy is possible only in a private-key settings and thus cannot be achieved in our multi-writer scenario; alternatively, one has to consider the case in which the function is sampled from a sufficiently large space [10].

Roadmap.

In Section 2, we give formal definition for the notion of a Secure Selective Stream. We also give two security notions and prove equality of the notions for access policies of our interest.

In Section 3, we introduce the notion of an Amortized Orthogonality Encryption, and show how to constuct a Secure Selective Stream using an Amortized Orthogonality Encryption as a black box.

In Section 4, we give a construction of an Amortized Orthogonality Encryption and prove its security under hardness assumptions in Bilinear settings.

Finally, in Section 5 we describe our implementation and discuss the outcome of our experimental evaluation.

2 Secure Selective Stream

In this section, we introduce the notion of a Secure Selective Stream ($\mathsf{SSS}$) scheme and present two security definitions for it. We will prove that for a large class of policies, including the one for which we will provide a construction, the two security notions coincide.

2.1 Syntax

As described in Section 1, our scenario for $\mathsf{SSS}$ consists of four classes of parties: one Data Owner (DO), several independent Query Processors (QP), several independent Data Sources (DS), and several independent Query Sources (QS). Data is in the form of rows with the same number $n$ of cells. The Data Owner DO enables access to the data by providing tokens to the Query Sources ${\sf QS}$s who issue access requests consisting of pairs $(\mathtt{Pol},k)$, where $\mathtt{Pol}$ is a policy taken from a fixed set of supported policies $\mathbb{P}$ and $1\leq k\leq n$ is an integer. Typically, a policy $\mathtt{Pol}$ is a predicate evaluated on rows. Access request $(\mathtt{Pol},k)$ asks for access to cell $k$ of all rows $\mathtt{Row}$ such that $\mathtt{Pol}(\mathtt{Row})=\mathtt{True}$.

Definition 1

A Secure Selective Stream ($\mathsf{SSS}$) scheme consists of 6 efficient algorithms $({\mathsf{Init}},\allowbreak{\mathsf{AuthorizeSel}},\allowbreak{\mathsf{AuthorizeDec}},\allowbreak{\mathsf{Encrypt}},\allowbreak{\mathsf{Select}},\allowbreak{\mathsf{Decrypt}})$ that are used by the parties of our scenario in the following way.

• •

The DO, on input the security parameter $\lambda$ and the length $n$ of the rows, runs $(\mathtt{mpk},\mathtt{msk})\leftarrow{\mathsf{Init}}(1^{\lambda},1^{n})$ to obtain the master public key $\mathtt{mpk}$ and the master secret key $\mathtt{msk}$. The master public key $\mathtt{mpk}$ is given to all Data Sources, whereas the master secret key $\mathtt{msk}$ is kept secret by the DO.

• •

A DSruns $\mathtt{eRow}\leftarrow{\mathsf{Encrypt}}(\mathtt{mpk},\mathtt{Row})$ to produce an encrypted row $\mathtt{eRow}$ to be placed on the encrypted stream that is accessed by the QPs.

• •

Upon receiving an access request $(\mathtt{Pol},k)$ from a QS, the DO computes a pair consisting of predicate token $\mathtt{p}\mathtt{Tok}\leftarrow{\mathsf{AuthorizeSel}}(\mathtt{msk},\mathtt{Pol})$ and message token $\mathtt{m}\mathtt{Tok}\leftarrow{\mathsf{AuthorizeDec}}(\mathtt{msk},\mathtt{Pol},k)$. $\mathtt{p}\mathtt{Tok}$ can be used to select rows that satisfy the policy $\mathtt{Pol}$, whereas $\mathtt{m}\mathtt{Tok}$ can be applied to decrypt the $k$-th component of a row that satisfy $\mathtt{Pol}$. The pair $(\mathtt{p}\mathtt{Tok},\mathtt{m}\mathtt{Tok})$ is given to the ${\sf QS}$ that has made request. We expect that ${\sf DO}$ checks that the specific QS has the right to request a token for $(\mathtt{Pol},k)$. We do not elaborate further on this point.

• •

The ${\sf QS}$ gives the predicate token to a ${\sf QP}$ that will use it to select the rows that satisfy $\mathtt{Pol}$ by running $\{0,1\}\leftarrow{\mathsf{Select}}(\mathtt{eRow},\mathtt{p}\mathtt{Tok})$ on the encrypted rows that appear in the stream. The selected rows are passed to the ${\sf QS}$.

• •

The ${\sf QS}$ decrypts the $k$-th component of an encrypted row $\mathtt{eRow}$ by running $\mathtt{Row}_{k}\leftarrow{\mathsf{Decrypt}}(\mathtt{eRow},\mathtt{m}\mathtt{Tok},k)$.

We remark that in our model a ${\sf QS}$ does not directly access the encrypted stream but rather it delegates a ${\sf QP}$ to select the rows of interest for the ${\sf QS}$ to decrypt. The ${\sf QP}$ is not necessarily trusted and thus will not have access to the stream of data in plain, not even to the cells of the selected rows that the ${\sf QS}$ is authorized to read. We stress that our model and implementation are flexible enough to allow a ${\sf QS}$ that has direct access to the encrypted stream to subsume the role of a ${\sf QP}$.

We next give two security definitions for $\mathsf{SSS}$: a simulation-based one and a game-based one. We shall prove that, for a class of supported policies that we call invertible, the two notions are equivalent.

2.2 Simulation-based security

We start by defining the concept of an instance of $\mathsf{SSS}$ and of a view of an adversary with respect to an instance.

Definition 2

An $(n,m,l)$-instance $\mathcal{I}=({\mathsf{Stream}},{\mathsf{AccReq}})$ of an $\mathsf{SSS}$ with supported set $\mathbb{P}$ of policies consists of two components:

• •

a stream ${\mathsf{Stream}}=((\mathtt{Row}_{1},\mathtt{id}\mathtt{S}_{1}),\ldots,(\mathtt{Row}_{m},\mathtt{id}\mathtt{S}_{m}))$ of $m$ pairs each consisting of a row $\mathtt{Row}_{i}$ with $n$ cells and of the identifier $\mathtt{id}\mathtt{S}_{i}$ of the ${\sf DS}$ that has originated the row;

• •

*a sequence of access requests ${\mathsf{AccReq}}=({\mathsf{AccReq}}_{1},\ldots,{\mathsf{AccReq}}_{l})$, where each *

${\mathsf{AccReq}}_{j}=((\mathtt{Pol}_{j},k_{j}),\mathtt{id}\mathtt{Q}_{j},\mathtt{id}\mathtt{P}_{j})$* consists of an access request $(\mathtt{Pol}_{j},k_{j})$ with $\mathtt{Pol}_{j}\in\mathbb{P}$, of the identifier, $\mathtt{id}\mathtt{Q}_{j}$, of the ${\sf QS}$ that has issued the $j$-th access request and of the identifier, $\mathtt{id}\mathtt{P}_{j}$, of the ${\sf QP}$ that handles the request on behalf of $\mathtt{id}\mathtt{Q}_{j}$.*

Let $\mathsf{C}=\mathsf{C}_{S}\cup\mathsf{C}_{P}\cup\mathsf{C}_{Q}$ be a coalition consisting of a set $\mathsf{C}_{S}$ of $n_{S}$ DSs, a set $\mathsf{C}_{P}$ of $n_{P}$ QPs, and a set $\mathsf{C}_{Q}$ of $n_{Q}$ QSs. We next define ${\sf{View}}^{\mathsf{C}}(\lambda,\mathcal{I})$, the view in the ${\sf{RealGame}}$ of a coalition $\mathsf{C}$ for an $(n,m,l)$-instance $\mathcal{I}=({\mathsf{Stream}},{\mathsf{AccReq}})$ and security parameter $\lambda$.

Definition 3

Let $S$ be an $\mathsf{SSS}$. The view with respect to $S$, ${\sf{View}}^{\mathsf{C}}_{S}(\lambda,\mathcal{I})$, of a coalition $\mathsf{C}=\mathsf{C}_{S}\cup\mathsf{C}_{P}\cup\mathsf{C}_{Q}$ for a $(n,m,l)$-instance $\mathcal{I}=({\mathsf{Stream}},{\mathsf{AccReq}})$ and security parameter $\lambda$ is produced by the following ${\sf{RealGame}}^{\mathsf{C}}_{S}(\lambda,\mathcal{I})$ experiment

Set $(\mathtt{mpk},\mathtt{msk})\leftarrow{\mathsf{Init}}(1^{\lambda},1^{n})$. 2. 2.

Write ${\mathsf{Stream}}$ as ${\mathsf{Stream}}=((\mathtt{Row}_{1},\mathtt{id}\mathtt{S}_{1}),\ldots,(\mathtt{Row}_{m},\mathtt{id}\mathtt{S}_{m}))$.

For each $(\mathtt{Row}_{i},\mathtt{id}\mathtt{S}_{i})$ with $i\in[m]$

set $\mathtt{eRow}_{i}\leftarrow{\mathsf{Encrypt}}(\mathtt{mpk},\mathtt{Row}_{i})$;

if $\mathtt{id}\mathtt{S}_{i}\in{\mathcal{C}}_{S}$ then set ${\mathtt{v}\mathtt{Row}}_{i}=\mathtt{Row}_{i}$ else set ${\mathtt{v}\mathtt{Row}}_{i}=\perp$;

set ${\mathtt{e}\mathtt{Row}}=(\mathtt{eRow}_{1},\ldots,\mathtt{eRow}_{m})$ and set ${\mathtt{v}\mathtt{Row}}=({\mathtt{v}\mathtt{Row}}_{1},\ldots,{\mathtt{v}\mathtt{Row}}_{m})$. 3. 3.

Write ${\mathsf{AccReq}}$ as ${\mathsf{AccReq}}=({\mathsf{AccReq}}_{1},\ldots,{\mathsf{AccReq}}_{l})$.

For each $j\in[l]$

write ${\mathsf{AccReq}}_{j}$ as ${\mathsf{AccReq}}_{j}=((\mathtt{Pol}_{j},k_{j}),\mathtt{id}\mathtt{Q}_{j},\mathtt{id}\mathtt{P}_{j})$;

set $\mathtt{p}\mathtt{Tok}_{j}\leftarrow{\mathsf{AuthorizeSel}}(\mathtt{msk},\mathtt{Pol}_{j})$;

set $\mathtt{m}\mathtt{Tok}_{j}\leftarrow{\mathsf{AuthorizeDec}}(\mathtt{msk},\mathtt{Pol}_{j},k_{j})$;

if $\mathtt{id}\mathtt{P}_{j}\in\mathsf{C}_{P}$ or $\mathtt{id}\mathtt{Q}_{j}\in\mathsf{C}_{Q}$ then $\mathtt{v}\mathtt{p}\mathtt{Tok}_{j}=\mathtt{p}\mathtt{Tok}_{j}$ else $\mathtt{v}\mathtt{p}\mathtt{Tok}_{j}=\perp$;

if $\mathtt{id}\mathtt{Q}_{j}\in\mathsf{C}_{Q}$ then $\mathtt{v}\mathtt{m}\mathtt{Tok}_{j}=\mathtt{m}\mathtt{Tok}_{j}$ else $\mathtt{v}\mathtt{m}\mathtt{Tok}_{j}=\perp$;

set $\mathtt{v}\mathtt{Tok}_{j}=(\mathtt{v}\mathtt{p}\mathtt{Tok}_{j},\mathtt{v}\mathtt{m}\mathtt{Tok}_{j})$;

if $\mathtt{id}\mathtt{Q}_{j}\in\mathsf{C}_{Q}$ then $\mathtt{v}\mathtt{Pol}_{j}=(\mathtt{Pol}_{j},k_{j})$;

if $\mathtt{id}\mathtt{Q}_{j}\not\in\mathsf{C}_{Q}$ and $\mathtt{id}\mathtt{P}_{j}\in\mathsf{C}_{P}$ then $\mathtt{v}\mathtt{Pol}_{j}=(\mathtt{Pol}_{j},\perp)$;

if $\mathtt{id}\mathtt{Q}_{j}\not\in\mathsf{C}_{Q}$ and $\mathtt{id}\mathtt{P}_{j}\not\in\mathsf{C}_{P}$ then $\mathtt{v}\mathtt{Pol}_{j}=(\perp,\perp)$;

set $\mathtt{v}\mathtt{Tok}=(\mathtt{v}\mathtt{Tok}_{1},\ldots,\mathtt{v}\mathtt{Tok}_{l})$;

set $\mathtt{v}\mathtt{Pol}=(\mathtt{v}\mathtt{Pol}_{1},\ldots,\mathtt{v}\mathtt{Pol}_{l})$. 4. 4.

Output ${\sf{View}}_{S}^{\mathsf{C}}(\lambda,\mathcal{I})=(\mathtt{mpk},{\mathtt{e}\mathtt{Row}},{\mathtt{v}\mathtt{Row}},\mathtt{v}\mathtt{Tok},\mathtt{v}\mathtt{Pol}).$

Leakage.

We next define the minimal leakage $\mathsf{mL}(\mathsf{C},\mathcal{I})$ which is obtained by a coalition $\mathsf{C}=\mathsf{C}_{S}\cup\mathsf{C}_{P}\cup\mathsf{C}_{Q}$ about a $(n,m,l)$-instance $\mathcal{I}=({\mathsf{Stream}},{\mathsf{AccReq}})$ in $\mathsf{SSS}$. Roughly speaking, the minimal leakage of an instance $\mathcal{I}$ consists of all data that is either originated by members of the coalition or for which the coalition is authorized. It consists of the following components:

The parameters $n,m$ and $l$ that are, respectively, the number of cells per row, the total number of rows composing the stream and the number of access requests; 2. 2.

Write ${\mathsf{Stream}}$ as ${\mathsf{Stream}}=((\mathtt{Row}_{1},\mathtt{id}\mathtt{S}_{1}),\ldots,(\mathtt{Row}_{m},\mathtt{id}\mathtt{S}_{m}))$.

For each $(\mathtt{Row}_{i},\mathtt{id}\mathtt{S}_{i})$, with $i\in[m]$, define ${\mathtt{l}}\mathtt{Row}_{i}$ as follows:

if $\mathtt{id}\mathtt{S}_{i}\in\mathsf{C}_{S}$ then ${\mathtt{l}}\mathtt{Row}_{i}=\mathtt{Row}_{i}$ else ${\mathtt{l}}\mathtt{Row}_{i}=\perp$.

Define ${\mathtt{l}}\mathtt{Row}=({\mathtt{l}}\mathtt{Row}_{1},\ldots,{\mathtt{l}}\mathtt{Row}_{m})$. 3. 3.

For each access request ${\mathsf{AccReq}}_{j}=((\mathtt{Pol}_{j},k_{j}),\mathtt{id}\mathtt{Q}_{j},\mathtt{id}\mathtt{P}_{j})$, with $j\in[l]$, define ${\mathtt{l}}\mathtt{Pol}_{j}$ and ${\mathtt{l}}\mathtt{k}_{j}$ as follows:

if $\mathtt{id}\mathtt{P}_{j}\in\mathsf{C}_{P}$ or $\mathtt{id}\mathtt{Q}_{j}\in\mathsf{C}_{Q}$ then ${\mathtt{l}}\mathtt{Pol}_{j}=\mathtt{Pol}_{j}$ else ${\mathtt{l}}\mathtt{Pol}_{j}=\perp$;

if $\mathtt{id}\mathtt{Q}_{j}\in\mathsf{C}_{Q}$ then ${\mathtt{l}}\mathtt{k}_{j}=k_{j}$ else ${\mathtt{l}}\mathtt{k}_{j}=\perp$. 4. 4.

For each access request ${\mathsf{AccReq}}_{j}=((\mathtt{Pol}_{j},k_{j}),\mathtt{id}\mathtt{Q}_{j},\mathtt{id}\mathtt{P}_{j})$, with $j\in[l]$, and for each $\mathtt{Row}_{i}$, with $i\in[m]$, define ${\mathtt{l}}\mathtt{Sel}_{i,j}$ and ${\mathtt{l}}\mathtt{Val}_{i,j}$ as follows:

if $\mathtt{id}\mathtt{Q}_{j}\in\mathsf{C}_{Q}$ or $\mathtt{id}\mathtt{P}_{j}\in\mathsf{C}_{P}$ then ${\mathtt{l}}\mathtt{Sel}_{i,j}={\mathtt{l}}\mathtt{Pol}_{j}(\mathtt{Row}_{i})$ else ${\mathtt{l}}\mathtt{Sel}_{i,j}=\perp$;

if $\mathtt{id}\mathtt{Q}_{j}\in\mathsf{C}_{Q}$ and $\mathtt{Pol}_{j}(\mathtt{Row}_{i})=\mathtt{True}$ then ${\mathtt{l}}\mathtt{Val}_{i,j}=\mathtt{Row}_{i,k_{j}}$ else ${\mathtt{l}}\mathtt{Val}_{i,j}=\perp$;

Define ${\mathtt{l}}\mathtt{Sel}_{j}=({\mathtt{l}}\mathtt{Sel}_{1,j},\ldots,{\mathtt{l}}\mathtt{Sel}_{m,j})$ and ${\mathtt{l}}\mathtt{Val}_{j}=({\mathtt{l}}\mathtt{Val}_{1,j},\ldots,{\mathtt{l}}\mathtt{Val}_{m,j})$. 5. 5.

For each access request ${\mathsf{AccReq}}_{j}$, define ${\mathtt{l}}\mathtt{Req}_{j}=({\mathtt{l}}\mathtt{Pol}_{j},{\mathtt{l}}\mathtt{k}_{j},{\mathtt{l}}\mathtt{Sel}_{j},{\mathtt{l}}\mathtt{Val}_{j})$ and ${\mathtt{l}}\mathtt{Req}=({\mathtt{l}}\mathtt{Req}_{1},\ldots,\allowbreak{\mathtt{l}}\mathtt{Req}_{l})$. 6. 6.

Set $\mathsf{mL}(\mathsf{C},\mathcal{I})=({\mathtt{l}}\mathtt{Row},{\mathtt{l}}\mathtt{Req})$.

We are now ready for our simulation-based security definition.

Definition 4

An $\mathsf{SSS}$ is simulation-based secure with respect to leakage $\mathcal{L}$ if there exists a probabilistic polynomial-time (PPT) simulator ${\sf{Sim}}$ such that, for all coalitions $\mathsf{C}$ and $n,m,l=poly(\lambda)$, the families

[TABLE]

are indistinguishable.

Definition 5

An $\mathsf{SSS}$ is simulation-based secure if it is simulation-based secure with respect to minimal leakage $\mathsf{mL}$.

2.3 Game-based security

Now, we give our second, game-based security definition. We model security of $\mathsf{SSS}$ by means of two games, $\mathsf{SSDGame}^{0}$ and $\mathsf{SSDGame}^{1}$, between a challenger ${\sf Ch}$ and a probabilistic polynomial-time adversary ${\cal A}$. The game $\mathsf{SSDGame}_{\cal A}^{\eta}(\lambda)$ for $\eta=0,1$, security parameter $\lambda$ and adversary ${\cal A}$ starts with ${\cal A}$ outputting two challenge streams ${\mathsf{Stream}}_{0}$ and ${\mathsf{Stream}}_{1}$ and a coalition $\mathsf{C}$ of corrupted players. ${\sf Ch}$ receives the challenge streams, computes $(\mathtt{mpk},\mathtt{msk})\leftarrow{\mathsf{Init}}(1^{\lambda},1^{n})$ and sends the master public key $\mathtt{mpk}$ to ${\cal A}$. Moreover, ${\sf Ch}$ returns ${\mathsf{e}{\mathsf{Stream}}}={\mathsf{Encrypt}}(\mathtt{mpk},{\mathsf{Stream}}_{\eta})$ to ${\cal A}$. The query phase then starts and ${\cal A}$ can issue ${\mathsf{AccReq}}_{j}=((\mathtt{Pol}_{j},k_{j}),\mathtt{id}\mathtt{Q}_{j},\mathtt{id}\mathtt{P}_{j})$, for $j=1,\ldots,l={\mathtt{poly}}(\lambda)$, of its choice in order to receive predicate and message tokens $\mathtt{p}\mathtt{Tok}$ and $\mathtt{m}\mathtt{Tok}$ from the challenger ${\sf Ch}$ according to whether $\mathtt{id}\mathtt{Q}_{j},\mathtt{id}\mathtt{P}_{j}\in\mathsf{C}$. After ${\cal A}$ has finished issuing its queries, it outputs bit $b$ and we denote by $p^{\eta}_{\cal A}(\lambda)$ the probability that ${\cal A}$ outputs $q$.

We let $\mathcal{I}_{0}=({\mathsf{Stream}}_{0},{\mathsf{AccReq}})$ and $\mathcal{I}_{1}=({\mathsf{Stream}}_{1},{\mathsf{AccReq}})$, where ${\mathsf{AccReq}}=({\mathsf{AccReq}}_{1},\ldots,{\mathsf{AccReq}}_{l})$. We say that ${\cal A}$ is an admissible adversary if $\mathsf{mL}(\mathsf{C},\mathcal{I}_{0})=\mathsf{mL}(\mathsf{C},\mathcal{I}_{1})$.

Definition 6

An $\mathsf{SSS}$ $S$ is game-based secure if, for all admissible PPT adversaries ${\cal A}$

[TABLE]

2.4 Invertible policies

In this section, we define a class of policies, that we call invertible, and we show that, for $\mathsf{SSS}$ supporting an invertible set of policies, the two notions of security of Definition 5 and Definition 6 are equivalent.

We start by defining the concept of a constraint and of a compatible set of constraints. We identify three types of constraints for a set $\mathbb{P}$ of supported policies over rows of length $n$.

• •

Full Positive Constraint: $\mathtt{ctr}=(\mathtt{Pol},k,\mathtt{val})$ consisting of policy $\mathtt{Pol}\in\mathbb{P}$, integer $1\leq k\leq n$ and value $\mathtt{val}$. A row $\mathtt{Row}=\langle\mathtt{Row}_{1},\ldots,\mathtt{Row}_{n}\rangle$ is admissible with respect to $\mathtt{ctr}$ if $\mathtt{Pol}(\mathtt{Row})=\mathtt{True}$ and $\mathtt{Row}_{k}=\mathtt{val}$.

• •

Positive Constraint: $\mathtt{ctr}=(\mathtt{Pol},\perp,\perp)$ consisting of policy $\mathtt{Pol}\in\mathbb{P}$. A row $\mathtt{Row}$ is admissible with respect to $\mathtt{ctr}$ if $\mathtt{Pol}(\mathtt{Row})=\mathtt{True}$.

• •

Negative constraint: $\mathtt{ctr}=(\mathtt{Pol},\perp,\perp)$ consisting of a policy $\mathtt{Pol}\in\mathbb{P}$. A row $\mathtt{Row}$ is admissible with respect to $\mathtt{ctr}$ if $\mathtt{Pol}(\mathtt{Row})=\mathtt{False}$.

Definition 7

A constraint set ${\mathcal{V}}=(\mathtt{ctr}^{\text{f}},\mathtt{ctr}^{+},\mathtt{ctr}^{-})$ consisting of a set $\mathtt{ctr}^{\text{f}}$ of full positive constraints, a set $\mathtt{ctr}^{+}$ of positive constraints and a set $\mathtt{ctr}^{-}$ of negative constraints is compatible if there exists at least one row $\mathtt{Row}$ that is admissible with respect to all constraints of ${\mathcal{V}}$.

We can now give the following definition of invertible policies.

Definition 8

A set of policies $\mathbb{P}$ is invertible if there exists a polynomial-time algorithm ${\mathsf{ConstAdm}}$ such that, for all compatible sets of constraints ${\mathcal{V}}=({\mathcal{V}}^{\text{f}},{\mathcal{V}}^{+},{\mathcal{V}}^{-})$, outputs a row $\mathtt{Row}$ admissible for ${\mathcal{V}}$.

The following two sections will prove equivalence of the game-based security notion and the simulation-based security notion for Secure Selective Stream supporting invertible policies.

Theorem 1

Let $S$ be an $\mathsf{SSS}$ supporting an invertible set of policies. Then $S$ is game-based secure if and only if $S$ is simulation-based secure.

2.5 Simulation-based security implies game-based security for invertible policies

In this section, we show that if $S$ is simulation-based secure $\mathsf{SSS}$ then it is also game-based secure. Let ${\cal A}$ be an admissible adversary for the security game $\mathsf{SSDGame}$ and let $\mathsf{C}$ be coalition output by ${\cal A}$ and $\mathcal{I}_{b}=({\mathsf{Stream}}_{b},{\mathsf{AccReq}})$, for $b=0,1$ be the instances defined by ${\cal A}$. Note that the two instances have the same minimal leakage (that is, $\mathsf{mL}(\mathcal{I}_{0})=\mathsf{mL}(\mathcal{I}_{1})$).

Now consider an hybrid game in in which the encrypted stream ${\mathsf{e}{\mathsf{Stream}}}$ is produced by running the simulator on input the minimum leakage associated with the coalition $\mathsf{C}$ (instead of setting ${\mathsf{e}{\mathsf{Stream}}}$ equal to an encryption of ${\mathsf{Stream}}_{0}$ or ${\mathsf{Stream}}_{1}$). Note that this is possible because the adversary of the security game is admissible and thus the two instances have the same minimal leakage with respect to $\mathsf{C}$. By the simulation-based security, the view of ${\cal A}$ in the hybrid game is indistinguishable from the view of the ${\cal A}$ in $\mathsf{SSDGame}$ for both $b=0$ and $b=1$. Therefore the probabilities $p^{0}_{\cal A}(\lambda)$ and $p^{1}_{\cal A}(\lambda)$ that ${\cal A}$ outputs $1$ in games $\mathsf{SSDGame}_{\cal A}^{0}(\lambda)$ and $\mathsf{SSDGame}_{\cal A}^{1}(\lambda)$, respectively, differ by a negligible factor.

2.6 Game-based security implies simulation-based security for invertible policies

For the reverse implication, we construct a simulator ${\sf{Sim}}$ that, for any $\mathsf{SSS}$ with invertible set of supported policies $\mathbb{P}$, has access to the procedure ${\mathsf{ConstAdm}}$ that takes as input a set $\mathtt{ctr}^{+}$ of satisfied access requests and a set $\mathtt{ctr}^{-}$ of unsatisfied access requests and returns a row that satisfies all constraints.

The simulator ${\sf{Sim}}$ takes as input the security parameter $1^{\lambda}$, a coalition $\mathsf{C}=\mathsf{C}_{S}\cup\mathsf{C}_{P}\cup\mathsf{C}_{Q}$ consisting of ${\sf DS}s,{\sf QP}s$ and ${\sf QS}s$ and the minimal leakage $\mathsf{mL}(\mathsf{C},\mathcal{I})$ for a $(n,m,l)$-instance $\mathcal{I}$. In addition ${\sf{Sim}}$ has black-box access to the algorithms of a $\mathsf{SSS}$ implementation. Roughly speaking, the main difficulty for ${\sf{Sim}}$ lies in producing the ciphertexts of the rows that appear in the stream. The rows that are produced by a corrupted ${\sf DS}$ are given in clear as part of the leakage and thus they can be just encrypted by ${\sf{Sim}}$. For each row $\mathtt{Row}_{i}$ that is produced by a honest ${\sf DS}$, ${\sf{Sim}}$ uses the leakage received as input to construct a set of constraints ${\mathcal{V}}_{i}=(\mathtt{ctr}_{i}^{\text{f}},\mathtt{ctr}_{i}^{+},\mathtt{ctr}_{i}^{-})$ that $\mathtt{Row}_{i}$ must respect. Then, instead of encrypting the actual $\mathtt{Row}_{i}$ appearing in the instance $\mathcal{I}$, ${\sf{Sim}}$ encrypts a row that is computed by algorithm ${\mathsf{ConstAdm}}$, whose existence is guaranteed by the hypothesis that the $\mathsf{SSS}$ implementation supports an invertible set of policies. Note that in this way, the simulator constructs an instance $\mathcal{I}^{\prime}$ that has the same leakage as the original instance $\mathcal{I}$. Indistinguishability of the output of ${\sf{Sim}}$ from the actual view of the coalition $\mathsf{C}$ then follows from the assumed game-based security of the implementation.

Let us now formally describe ${\sf{Sim}}(1^{\lambda},\mathsf{C},\mathsf{mL}(\mathsf{C},\mathcal{I}))$.

Write $\mathsf{mL}(\mathsf{C},\mathcal{I})$ as $\mathsf{mL}(\mathsf{C},\mathcal{I})=({\mathtt{l}}\mathtt{Row},{\mathtt{l}}\mathtt{Req})$ 2. 2.

Set $(\mathtt{mpk},\mathtt{msk})\leftarrow{\mathsf{Init}}(1^{\lambda},1^{n})$. 3. 3.

Write ${\mathtt{l}}\mathtt{Row}$ as ${\mathtt{l}}\mathtt{Row}=({\mathtt{l}}\mathtt{Row}_{1},\ldots,{\mathtt{l}}\mathtt{Row}_{m})$. 4. 4.

For $i\in[m]$ s.t. ${\mathtt{l}}\mathtt{Row}_{i}\neq\perp$, set $\mathtt{Row}_{i}={\mathtt{l}}\mathtt{Row}_{i}$. 5. 5.

For $i\in[m]$ s.t. ${\mathtt{l}}\mathtt{Row}_{i}=\perp$

Set $\mathtt{ctr}_{i}^{\text{f}}=\mathtt{ctr}_{i}^{+}=\mathtt{ctr}_{i}^{-}=\emptyset$;

For $j\in[l]$

Write ${\mathtt{l}}\mathtt{Req}_{j}$ as ${\mathtt{l}}\mathtt{Req}_{j}=({\mathtt{l}}\mathtt{Pol}_{j},{\mathtt{l}}\mathtt{k}_{j},{\mathtt{l}}\mathtt{Sel}_{j},{\mathtt{l}}\mathtt{Val}_{j})$;

If ${\mathtt{l}}\mathtt{Sel}_{i,j}=\mathtt{False}$ then $\mathtt{ctr}_{i}^{-}=\mathtt{ctr}_{i}^{-}\cup\{({\mathtt{l}}\mathtt{Pol}_{j},\perp,\perp)\}$’

If ${\mathtt{l}}\mathtt{Sel}_{i,j}=\mathtt{True}$ and ${\mathtt{l}}\mathtt{k}_{i,j}=\perp$ then $\mathtt{ctr}_{i}^{+}=\mathtt{ctr}_{i}^{+}\cup\{({\mathtt{l}}\mathtt{Pol}_{j},\perp,\perp)\}$;

If ${\mathtt{l}}\mathtt{Sel}_{i,j}=\mathtt{True}$ and ${\mathtt{l}}\mathtt{k}_{i,j}\neq\perp$ then $\mathtt{ctr}_{i}^{\text{f}}=\mathtt{ctr}_{i}^{\text{f}}\cup\{({\mathtt{l}}\mathtt{Pol}_{j},{\mathtt{l}}\mathtt{k}_{i,j},{\mathtt{l}}\mathtt{Val}_{i,j})\}$;

Set $\mathtt{Row}_{i}\leftarrow{\mathsf{ConstAdm}}(\mathtt{ctr}_{i}^{\text{f}},\mathtt{ctr}_{i}^{+},\mathtt{ctr}_{i}^{-})$; 6. 6.

For $i\in[m]$ set $\mathtt{eRow}_{i}\leftarrow{\mathsf{Encrypt}}(\mathtt{mpk},\mathtt{Row}_{i})$; 7. 7.

Set $\mathtt{eRow}=(\mathtt{eRow}_{1},\ldots,\mathtt{eRow}_{m})$ and ${\mathtt{v}\mathtt{Row}}={\mathtt{l}}\mathtt{Row}$. 8. 8.

For $j\in[l]$

Write ${\mathtt{l}}\mathtt{Req}_{j}$ as ${\mathtt{l}}\mathtt{Req}_{j}=({\mathtt{l}}\mathtt{Pol}_{j},{\mathtt{l}}\mathtt{k}_{j},{\mathtt{l}}\mathtt{Sel}_{j},{\mathtt{l}}\mathtt{Val}_{j})$;

if ${\mathtt{l}}\mathtt{Pol}_{j}\neq\perp$ then $\mathtt{v}\mathtt{p}\mathtt{Tok}_{j}\leftarrow{\mathsf{AuthorizeSel}}(\mathtt{msk},{\mathtt{l}}\mathtt{Pol}_{j})$ else $\mathtt{v}\mathtt{p}\mathtt{Tok}_{j}=\perp$;

if ${\mathtt{l}}\mathtt{Pol}_{j}\neq\perp$ and ${\mathtt{l}}\mathtt{k}_{j}\neq\perp$ then $\mathtt{v}\mathtt{m}\mathtt{Tok}_{j}\leftarrow{\mathsf{AuthorizeDec}}(\mathtt{msk},{\mathtt{l}}\mathtt{Pol}_{j},{\mathtt{l}}\mathtt{k}_{j})$ else $\mathtt{v}\mathtt{m}\mathtt{Tok}_{j}=\perp$;

set $\mathtt{v}\mathtt{Tok}_{j}=(\mathtt{v}\mathtt{p}\mathtt{Tok}_{j},\mathtt{v}\mathtt{m}\mathtt{Tok}_{j})$;

if ${\mathtt{l}}\mathtt{Pol}_{j}\neq\perp$ and ${\mathtt{l}}\mathtt{k}_{j}=\perp$ then $\mathtt{v}\mathtt{Pol}_{j}=({\mathtt{l}}\mathtt{Pol}_{j},\perp)$;

if ${\mathtt{l}}\mathtt{Pol}_{j}\neq\perp$ and ${\mathtt{l}}\mathtt{k}_{j}\neq\perp$ then $\mathtt{v}\mathtt{Pol}_{j}=({\mathtt{l}}\mathtt{Pol}_{j},{\mathtt{l}}\mathtt{k}_{j})$;

if ${\mathtt{l}}\mathtt{Pol}_{j}=\perp$ and ${\mathtt{l}}\mathtt{k}_{j}=\perp$ then $\mathtt{v}\mathtt{Pol}_{j}=(\perp,\perp)$;

set $\mathtt{v}\mathtt{Tok}=(\mathtt{v}\mathtt{Tok}_{1},\ldots,\mathtt{v}\mathtt{Tok}_{l})$;

set $\mathtt{v}\mathtt{Pol}=(\mathtt{v}\mathtt{Pol}_{1},\ldots,\mathtt{v}\mathtt{Pol}_{l})$. 9. 9.

Return $(\mathtt{mpk},{\mathtt{e}\mathtt{Row}},{\mathtt{v}\mathtt{Row}},\mathtt{v}\mathtt{Tok},\mathtt{v}\mathtt{Pol})$.

Security proof.

For the sake of contradiction, we assume the existences of an adversary ${\cal A}$ that distinguishes between $\{{\sf{View}}^{\mathsf{C}}_{\sf{RealGame}}(\lambda,\mathcal{I})\}\text{ and }\{{\sf{Sim}}(1^{\lambda},\mathcal{L}(\mathsf{C},\mathcal{I}))\}$. We then construct a probabilistic polynomial time adversary ${\cal B}$ that breaks game $\mathsf{SSDGame}$ thus reaching a contradiction.

We consider a series of hybrid games $H_{0}(\lambda,\mathcal{I}),\ldots,H_{n}(\lambda,\mathcal{I})$ that are obtained from $\mathsf{SSDGame}$ executed on instances derived from $\mathcal{I}$. Specifically, for an instance $\mathcal{I}=({\mathsf{Stream}},{\mathsf{AccReq}})$ and for $i=0,\ldots,n$, in game $H_{i}(\lambda,\mathcal{I})$ the first $i$ rows of the stream are constructed by using ${\mathsf{ConstAdm}}$ on the constraint sets derived from ${\mathsf{AccReq}}$ and the remaining rows are the same as the ones in ${\mathsf{Stream}}$. Note that $H_{0}(\lambda,\mathcal{I})$ coincides with ${\sf{View}}^{\mathsf{C}}_{\sf{RealGame}}(\lambda,\mathcal{I})$ and $H_{n}(\lambda,\mathcal{I})$ instead coincides with ${\sf{Sim}}(1^{\lambda},\mathsf{mL}(\mathsf{C},\mathcal{I}))$. Therefore, if ${\cal A}$ has a non-negligible advantage in distinguishing $H_{0}$ and $H_{n}$, there must exist $i$ such that ${\cal A}$ has non-negligible advantage in distinguishing $H_{i}$ and $H_{i+1}$. That is, by denoting with $p_{\cal A}^{i}(\lambda,I)$ and $p_{\cal A}^{i+1}(\lambda,\mathcal{I})$ the probabilities that ${\cal A}$ outputs $1$ when the input is distributed according to $H_{i}(\lambda,\mathcal{I})$ and to $H_{i+1}(\lambda,\mathcal{I})$, we have

[TABLE]

for some polynomial ${\mathtt{poly}}$.

Algorithm ${\cal B}$ interacts with the challenger ${\sf Ch}$ of $\mathsf{SSDGame}$ and prepares two streams: ${\mathsf{Stream}}_{0}$ is like in $H_{i}$, that is the first $i$ rows are constructed by using ${\mathsf{ConstAdm}}$ and the remaining ones are from ${\mathsf{Stream}}$ as appearing in instance $\mathcal{I}$; ${\mathsf{Stream}}_{1}$ is like in $H_{i+1}$, that is the first $i$ rows are constructed by using ${\mathsf{ConstAdm}}$ and the remaining ones are from ${\mathsf{Stream}}$ as appearing in instance $\mathcal{I}$. Then ${\cal B}$ requests from ${\sf Ch}$ the tokens as specified in ${\mathsf{AccReq}}$ and constructs the view consisting of all the messages received from ${\sf Ch}$ and passes it to ${\cal A}$ receiving a bit $b$. Then ${\cal B}$ outputs $b$ and stops.

We note that ${\cal B}$ is an admissible adversary since the leakages for $\mathcal{I}_{0}=({\mathsf{Stream}}_{0},{\mathsf{AccReq}})$ and $\mathcal{I}_{1}=({\mathsf{Stream}}_{1},{\mathsf{AccReq}})$ coincide. Moreover, if ${\cal B}$ in engaged in $\mathsf{SSDGame}^{0}$ with ${\sf Ch}$, then the view constructed is exactly the same as in $H_{i}$ whereas, when engaged in $\mathsf{SSDGame}^{1}$, it coincides with $H_{i+1}$. Therefore, by denoting with $p^{0}_{\cal B}(\lambda)$ and $p^{1}_{\cal B}(\lambda)$ the probabilities that ${\cal B}$ outputs $1$ in $\mathsf{SSDGame}^{0}$ and $\mathsf{SSDGame}^{1}$, respectively, we have that $p^{0}_{\cal B}(\lambda)=p_{\cal A}^{i}(\lambda,\mathcal{I})$ and $p^{1}_{\cal B}(\lambda)=p_{\cal A}^{i+1}(\lambda,\mathcal{I})$. Therefore by Equation 1 we conclude that ${\cal B}$ is a successful adversary, thus reaching contradiction.

3 Constructing $\mathsf{SSS}$ from $\mathsf{AOE}$

In this section we describe a construction of a $\mathsf{SSS}$ scheme where cells are elements in $\mathbb{Z}_{p}$ and the set of supported policies $\mathbb{CONJ}$ contains policies expressed as conjunctions of equality predicates. Specifically, a policy $(\mathtt{Pol},k)\in\mathbb{CONJ}$, consists of $\mathtt{Pol}=(\mathtt{Pol}_{1},\ldots,\mathtt{Pol}_{n})\in(\mathbb{Z}_{p}\cup\{\star\})^{n}$, and, for a row $\mathtt{Row}=(\mathtt{Row}_{1},\ldots,\mathtt{Row}_{n})$, we have $\mathtt{Pol}(\mathtt{Row})=\mathtt{True}$ iff, for all $i=1,\ldots,n$, we have that

[TABLE]

where $\star$ is a “don’t care” symbol.

Our construction uses as a black-box an Amortized Orthogonality Encryption ($\mathsf{AOE}$) scheme and prove that the $\mathsf{SSS}$ constructed satisfies the game-based security notion if the $\mathsf{AOE}$ employed is also game-based secure.

In Section 4 we give a construction of $\mathsf{AOE}$ that can be proved secure under hardness assumptions in the Bilinear setting. In Section 3.5, we prove that the set $\mathbb{CONJ}$ of policies is invertible and thus we can conclude that our construction of $\mathsf{SSS}$ is also simulation-based secure, under hardness assumptions in the Bilinear setting.

We start by introducing the concept of an Amortized Orthogonality Encryption and its security notions.

3.1 Amortized Orthogonality Encryption

An $\mathsf{AOE}$ scheme is a generalisation of the orthogonality encryption schemes in which ciphertexts and keys are associated to attribute vectors of some fixed length over a finite field. A key associated with vector $S$ can decrypt a ciphertext associated with vector $X$, iff $S$ and $X$ are orthogonal. We denote by $\langle X,S\rangle$ the inner product of $X$ and $S$ that checks orthogonality of the two vectors. Also, for vector $X_{0}$ of length $n_{0}$ and vector $X_{1}$ of length $n_{1}$, we denote by $(X_{0},X_{1})$ the vector of length $n_{0}+n_{1}$ obtained by concatenating $X_{0}$ and $X_{1}$. In an Amortized Orthogonality Encryption scheme ($\mathsf{AOE}$) the encryption algorithm takes as input $n$ plaintexts $M_{1},\ldots,M_{n}$ each associated with a vector of length $u+v$ and the $n$ attribute vectors share the first $u$ components. The goal is to amortize the length of the ciphertexts so that it is proportional to $u+n\cdot v$ instead of proportional to $n\cdot(u+v)$. We will use an $\mathsf{AOE}$ with constant $v$ and $u=\Theta(n)$ which will make the total size of the $n$ ciphertext $\Theta(n)$, a considerable saving over $\Theta(n^{2})$. Let us start by defining the syntax of an $\mathsf{AOE}$ scheme.

Definition 9

An $\mathsf{AOE}$ scheme with message space ${\mathbb{M}}$ and attribute space ${\mathbb{X}}$ is a sequence of $6$ probabilistic polynomial-time algorithms $({\mathsf{ParGen}},{\mathsf{Enc}},{\mathsf{p}{\mathsf{KeyGen}}},$ ${\mathsf{m}{\mathsf{KeyGen}}},{\mathsf{p}{\mathsf{Dec}}},{\mathsf{m}{\mathsf{Dec}}})$ with the following syntax:

the parameter generator algorithm ${\mathsf{ParGen}}(1^{\lambda},1^{n},1^{u},1^{v})$ takes as input security parameter $\lambda$, multiplicity factor $n$, and length parameters $u$ and $v$ and outputs the master public key $\mathtt{mpk}$ and the master secret key $\mathtt{msk}$; 2. 2.

the encryption algorithm ${\mathsf{Enc}}(\mathtt{mpk},{\mathcal{X}},{\mathcal{M}})$ takes as input master public key $\mathtt{mpk}$, a sequence of vectors of attributes ${\mathcal{X}}\in{{\mathbb{X}}}^{u}\times({{\mathbb{X}}}^{v})^{n}$ and a sequence of messages ${\mathcal{M}}\in{\mathbb{M}}^{n}$ and outputs cumulative ciphertext $\mathtt{ct}=(\mathtt{ct}_{0},\mathtt{ct}_{1},\ldots,\mathtt{ct}_{n})$. 3. 3.

the P-token generator algorithm ${\mathsf{p}{\mathsf{KeyGen}}}$ takes as input the master secret key $\mathtt{msk}$, and the vector of attributes $S_{0}\in\mathbb{X}^{u}$ and outputs P-token $\mathtt{p}\mathtt{Tok}$; 4. 4.

the M-token generator algorithm ${\mathsf{m}{\mathsf{KeyGen}}}$ takes as input the master secret key $\mathtt{msk}$, the vectors of attributes $S_{0}\in\mathbb{X}^{u}$ and $S_{k}\in\mathbb{X}^{v}$ and integer $k\in\{1,\ldots,n\}$ and outputs M-token $\mathtt{m}\mathtt{Tok}$; 5. 5.

the P-decryption algorithm ${\mathsf{p}{\mathsf{Dec}}}$ takes as input the first component $\mathtt{ct}_{0}$ of a cumulative ciphertext $\mathtt{ct}$ and a P-token $\mathtt{p}\mathtt{Tok}$ and outputs [math] or $1$; 6. 6.

the M-decryption algorithm ${\mathsf{m}{\mathsf{Dec}}}$ takes as input a pair $(\mathtt{ct}_{0},\mathtt{ct}_{k})$ of components of a cumulative ciphertext and an M-token $\mathtt{m}\mathtt{Tok}$ and outputs either a message $M\in{\mathbb{M}}$ or $\perp$.

We have the following two correctness requirements.

Algorithm ${\mathsf{p}{\mathsf{Dec}}}$:* For every attribute vector $S_{0}\in{\mathbb{X}}^{u}$ and for every sequence ${\mathcal{X}}=(X_{0},X_{1},\ldots,X_{n})$ of attribute vectors such that $\langle S_{0},X_{0}\rangle=0$ and for every sequence ${\mathcal{M}}=(M_{1},\ldots,M_{n})$ of messages we have that if $(\mathtt{mpk},\mathtt{msk})\leftarrow{\mathsf{ParGen}}(1^{\lambda},1^{n},1^{u},1^{v})$, and $\mathtt{ct}\leftarrow{\mathsf{Enc}}(\mathtt{mpk},{\mathcal{X}},{\mathcal{M}})$, and $\mathtt{p}\mathtt{Tok}\leftarrow{\mathsf{p}{\mathsf{KeyGen}}}(\mathtt{msk},S_{0})$, then ${\mathsf{p}{\mathsf{Dec}}}(\mathtt{ct}_{0},\mathtt{p}\mathtt{Tok})=1$, except with probability negligible in $\lambda$.*

Algorithm ${\mathsf{m}{\mathsf{Dec}}}$:* For every $k\in\{1,\ldots,n\}$, for every attribute vectors $S_{0}\in\mathbb{X}^{u}$ and $S_{k}\in\mathbb{X}^{v}$, for every sequence ${\mathcal{X}}=(X_{0},X_{1},\ldots,X_{n})$ of attribute vectors and for every sequence ${\mathcal{M}}=(M_{1},\ldots,M_{n})$ of messages we have that if $(\mathtt{mpk},\mathtt{msk})\leftarrow{\mathsf{ParGen}}(1^{\lambda},1^{n},1^{u},1^{v})$, $\mathtt{ct}\leftarrow{\mathsf{Enc}}(\mathtt{mpk},{\mathcal{X}},{\mathcal{M}})$, and $\mathtt{m}\mathtt{Tok}\leftarrow{\mathsf{m}{\mathsf{KeyGen}}}(\mathtt{msk},\allowbreak(S_{0},S_{k},k))$ then, if $\langle(S_{0},S_{k}),(X_{0},X_{k})\rangle=0$ then ${\mathsf{m}{\mathsf{Dec}}}((\mathtt{ct}_{0},\mathtt{ct}_{k}),\mathtt{m}\mathtt{Tok})=M_{k}$, except with probability negligible in $\lambda$.*

3.2 Security game for $\mathsf{AOE}$

We model privacy of the attributes and of the plaintexts in a cumulative ciphertext of an $\mathsf{AOE}$ by means of game, $\mathsf{\mathsf{AOE}Game}$, between a challenger Ch and a probabilistic polynomial-time adversary ${\cal A}$. The game $\mathsf{\mathsf{AOE}Game}^{\cal A}(\lambda,n,u,v)$ takes as input the security parameter $\lambda$, the multiplicity factor $n$ and the length parameters $u$ and $v$.

The game starts with ${\cal A}$ outputting two challenge sequences of attributes ${\cal X}^{0}=(X_{0}^{0},\ldots,X_{n}^{0})$ and ${\cal X}^{1}=(X_{0}^{1},\ldots,X_{n}^{1})$, where $X_{0}^{0}$ and $X_{0}^{1}$ are attribute vectors of length $u$ and $X_{1}^{0}\ldots,X_{n}^{0},X_{1}^{1}\ldots,X_{n}^{1}$ have length $v$. 2. 2.

Ch generates a pair $(\mathtt{mpk},\mathtt{msk})$ by running ${\mathsf{ParGen}}$ on input $(1^{\lambda},1^{n},1^{u},1^{v})$, sends $\mathtt{mpk}$ to ${\cal A}$ and starts answering ${\cal A}$ queries. 3. 3.

${\cal A}$ can issue two types of queries that are answered by Ch by using $\mathtt{msk}$: M-token queries in which ${\cal A}$ asks to see the token corresponding to $(S_{0},S_{k},k)$ of his choice; and P-token queries in which ${\cal A}$ asks to see the token corresponding to attribute vector $S_{0}$ of his choice. 4. 4.

At any time, ${\cal A}$ may send two sequences of $n$ messages, ${\mathcal{M}}^{0}$ and ${\mathcal{M}}^{1}$, to ${\sf Ch}$ that replies by flipping a random bit $\xi$ and computing the challenge cumulative ciphertext $\mathtt{ct}^{\star}$ corresponding to plaintexts ${\mathcal{M}}^{\xi}$ encrypted with attributes ${\mathcal{X}}^{\xi}$. 5. 5.

At the end ${\cal A}$ outputs its guess $\xi^{\prime}$ for $\xi$.

We say that ${\cal A}$ wins the game if $\xi=\xi^{\prime}$ and

for all $(S_{0},S_{k},k)$ for which an M-token query has been issued by ${\cal A}$, we have that $\langle(S_{0},S_{k}),(X_{0}^{0},X_{k}^{0})\rangle\neq 0$ and $\langle(S_{0},S_{k}),(X_{0}^{1},X_{k}^{1})\rangle\neq 0$; 2. 2.

for all vectors $S_{0}$ for which a P-token query has been issued by ${\cal A}$, we have that $\langle S_{0},X_{0}^{0}\rangle=\langle S_{0},X_{0}^{1}\rangle$.

We denote by $p^{\cal A}(\lambda,n,u,v)$ the probability that ${\cal A}$ wins the game and give the following definition

Definition 10

An $\mathsf{AOE}$ scheme is secure if, for all adversaries ${\cal A}$ and values $n,u,v=poly(\lambda)$,

[TABLE]

is a negligible function of $\lambda$.

We remark that the notion of security above corresponds to selective attribute hiding and adaptive payload hiding.

3.3 Constructing $\mathsf{SSS}$

Now, we construct our

[TABLE]

based on $\mathsf{AOE}$ with messages from $\mathbb{G}_{T}$ and attributes from $\mathbb{Z}_{p}$, and on a symmetric key encryption scheme $\mathsf{SYM}=({\mathsf{enc}},{\mathsf{dec}})$ that takes secret keys and messages from $\mathbb{Z}_{p}$, for some prime $p$.

$\mathsf{SSS}.{\mathsf{Init}}(1^{\lambda},1^{n})$ algorithm. With $\lambda$ and $n$ in input, the algorithm sets $u=n+1$ and $v=2$ and returns $(\mathtt{mpk},\mathtt{msk})\leftarrow\mathsf{AOE}.{\mathsf{ParGen}}(1^{\lambda},1^{n},1^{u},1^{v})$. 2. 2.

$\mathsf{SSS}.{\mathsf{AuthorizeSel}}(\mathtt{msk},\mathtt{Pol})$ algorithm. The algorithm for generating a selection token takes as input the master secret key $\mathtt{msk}$ and a policy $\mathtt{Pol}=(\mathtt{Pol}_{1},\ldots,\mathtt{Pol}_{n})$, where, for $i=1,\ldots,n$, $\mathtt{Pol}_{i}\in\mathbb{Z}_{p}\cup\{\star\}$. The algorithm, for $i=1,\ldots,n$, sets $t_{i}=0$ if $\mathtt{Pol}_{i}=\star$, and otherwise it sets $t_{i}$ to a random value of $\mathbb{Z}_{p}$. The algorithm then constructs the vector of length $u=n+1$

[TABLE]

and computes and returns $\mathtt{p}\mathtt{Tok}\leftarrow\mathsf{AOE}.{\mathsf{p}{\mathsf{KeyGen}}}(\mathtt{msk},S_{0})$. 3. 3.

$\mathsf{SSS}.{\mathsf{AuthorizeDec}}(\mathtt{msk},\mathtt{Pol},k)$ algorithm. The algorithm for generating a decryption token takes as input the master secret key $\mathtt{msk}$, a policy $\mathtt{Pol}=(\mathtt{Pol}_{1},\ldots,\mathtt{Pol}_{n})$ and integer $k\in\{1,\ldots,n\}$. A vector $S_{0}$ of length $u$ is created as for algorithm ${\mathsf{AuthorizeSel}}$, together with an additional vector $S_{k}=(k,-1)$ of length $v$. The algorithm returns $\mathtt{m}\mathtt{Tok}\leftarrow\mathsf{AOE}.{\mathsf{m}{\mathsf{KeyGen}}}(\mathtt{msk},S_{0},S_{k},k)$. 4. 4.

$\mathsf{SSS}.{\mathsf{Encrypt}}(\mathtt{mpk},\mathtt{Row})$ algorithm. The algorithm takes as input the master public key $\mathtt{mpk}$ and a $\mathtt{Row}$ with $n$ cells $\mathtt{Row}_{1},\ldots,\mathtt{Row}_{n}$. The algorithm randomly selects ${\mathcal{M}}=M_{i}\in\mathbb{G}_{T}$, for $i=1,\ldots,n$, and it generates $\mathtt{sk}_{i}={\mathcal{H}}(M_{i})$. Values $\mathtt{sk}_{1},\ldots,\mathtt{sk}_{n}$ are keys used to encrypt every cell as $\mathtt{c}_{i}\leftarrow\mathsf{SYM}.{\mathsf{enc}}(\mathtt{sk}_{i},\mathtt{Row}_{i})$. Then, it sets

[TABLE]

and

[TABLE]

Vector $X_{0}$ has length $u$, whereas the others have length $v$, and all of the vectors compose the sequence of vectors ${\mathcal{X}}\in\mathbb{Z}_{p}^{u}\times(\mathbb{Z}_{p}^{v})^{n}$, used as input of algorithm $\mathsf{AOE}.{\mathsf{Enc}}(\mathtt{mpk},{\mathcal{X}},{\mathcal{M}})$. The result $\mathtt{ct}=(\mathtt{ct}_{0},\mathtt{ct}_{1},\ldots,\mathtt{ct}_{n})$ is used together with $\mathtt{c}=(\mathtt{c}_{1},\ldots,\mathtt{c}_{n})$ to produce the output $\mathtt{eRow}=(\mathtt{ct},\mathtt{c})$. 5. 5.

$\mathsf{SSS}.{\mathsf{Select}}(\mathtt{eRow},\mathtt{p}\mathtt{Tok})$ algorithm. It takes as input the ciphertexts $\mathtt{eRow}=(\mathtt{ct},\mathtt{c})$, where $\mathtt{ct}=(\mathtt{ct}_{0},\mathtt{ct}_{1},\ldots,\mathtt{ct}_{n})$, and a selection token $\mathtt{p}\mathtt{Tok}$. It gives as a result the output of $\mathsf{AOE}.{\mathsf{p}{\mathsf{Dec}}}(\mathtt{ct}_{0},\mathtt{p}\mathtt{Tok})$. 6. 6.

$\mathsf{SSS}.{\mathsf{Decrypt}}(\mathtt{eRow},\mathtt{m}\mathtt{Tok},k)$ algorithm. It takes in input the ciphertexts $\mathtt{eRow}$ composed of $\mathtt{ct}=(\mathtt{ct}_{0},\ldots,\mathtt{ct}_{n})$ and $\mathtt{c}=(\mathtt{c}_{1},\ldots,\mathtt{c}_{n})$, a decryption token $\mathtt{m}\mathtt{Tok}$ and the integer $k\in\{1,\ldots,n\}$. The algorithm firstly computes the value $M_{k}\leftarrow\mathsf{AOE}.{\mathsf{m}{\mathsf{Dec}}}(ct_{0},\mathtt{ct}_{k},\mathtt{m}\mathtt{Tok})$. It then retrieves the decryption key $\mathtt{sk}_{k}$ for the symmetric key encryption scheme by making use of the hash function ${\mathcal{H}}(M_{k})$. Finally, the message is decrypted and given as output $\mathtt{Row}_{k}\leftarrow\mathsf{SYM}.{\mathsf{dec}}(\mathtt{sk}_{k},\mathtt{c}_{k})$.

3.4 Security of the $\mathsf{SSS}$ construction

The proposed construction makes black-box use of the two cryptographic primitives Amortized Orthogonality Encryption $\mathsf{AOE}$ and Symmetric Key Encryption $\mathsf{SYM}$. We next show that if $\mathsf{AOE}$ is game-based secure and $\mathsf{SYM}$ is IND-CPA secure then the construction of $\mathsf{SSS}$ is game-based secure.

We proceed by contradiction and assume the existence of an admissible adversary ${{\cal A}}$ that wins the security game of $\mathsf{SSS}$ (see Section 2.3) and describe an adversary ${\cal B}$ that wins the security game of $\mathsf{AOE}$. Our description gives details on how the process is initialized, how ${\cal B}$ constructs the challenge ciphertext and it answers ${{\cal A}}$’s queries for tokens.

We here make use of an $\mathsf{AOE}$ with attribute and message spaces $\mathbb{Z}_{p}$, and of a $\mathsf{SYM}$ with key and message spaces $\mathbb{Z}_{p}$.

Init. ${\cal B}$ receives two streams, ${\mathsf{Stream}}^{0}$ and ${\mathsf{Stream}}^{1}$, of length $m$, and coalition $\mathsf{C}$ of corrupted players from ${{\cal A}}$. We assume that ${\mathsf{Stream}}^{0}$ and ${\mathsf{Stream}}^{1}$ differ in exactly one position. This is without loss of generality since, if this is not the case, we can consider $m+1$ intermediate streams ${\mathsf{Stream}}_{0},{\mathsf{Stream}}_{1},\ldots,{\mathsf{Stream}}_{m}$ where ${\mathsf{Stream}}_{i}$ has the first $i$ components equal to the first $i$ components of ${\mathsf{Stream}}^{1}$ and the remaining $m-i$ equal to the last $m-i$ components of ${\mathsf{Stream}}^{0}$. Clearly, ${\mathsf{Stream}}_{0}={\mathsf{Stream}}^{0}$ and ${\mathsf{Stream}}_{m}={\mathsf{Stream}}^{1}$ and, if ${\cal B}$ has a non-negligible advantage in distinguishing ${\mathsf{Stream}}_{0}$ and ${\mathsf{Stream}}_{m}$, there must exist $i$ such that ${\cal B}$ has a non-negligible advantage in distinguishing ${\mathsf{Stream}}_{i}$ and ${\mathsf{Stream}}_{i+1}$. Then observe that ${\mathsf{Stream}}_{i}$ and ${\mathsf{Stream}}_{i+1}$ differ in exactly one component.

We also observe that neither of the two ${\sf DS}$s associated to the two components of the two streams is corrupted, otherwise the leakage associated with the two streams would not be equal, thus contradicting the fact that ${{\cal A}}$ is an admissible adversary. Since neither is corrupted we can assume that they are the same ${\sf DS}$.

Finally, without loss of generality, we can assume that the two streams differ in the first component. Thus we can summarize and write the two streams as

[TABLE]

and

[TABLE]

Computing the challenge. ${\cal B}$ sets $u=n+1$ and $v=2$ and starts game $\mathsf{\mathsf{AOE}Game}(\lambda,n,u,v)$ with ${\sf Ch}$. ${\cal B}$ starts by computing the two challenge sequences of attributes ${\mathcal{X}}^{0}$ and ${\mathcal{X}}^{1}$ as done by algorithm ${\mathsf{Encrypt}}$ on input $\mathtt{Row}^{0}_{1}$ and $\mathtt{Row}^{1}_{1}$, respectively. Specifically, ${\cal B}$ sets

[TABLE]

and

[TABLE]

and $X_{i}^{0}=X_{i}^{1}=(1,i)$ for $i=1,\ldots,n$.

Moreover, ${\cal B}$ randomly selects messages $M_{1},\ldots,M_{n}\in\mathbb{Z}_{p}$ and sets ${\mathcal{M}}^{0}={\mathcal{M}}^{1}=(M_{1},\ldots,M_{n})$.

Then ${\cal B}$ sends attribute sequences ${\mathcal{X}}^{0}=(X_{0}^{0},X_{1}^{0},\ldots,X_{n}^{0})$ and ${\mathcal{X}}^{1}=(X_{0}^{1},X_{1}^{1},\ldots,X_{n}^{1})$ and message sequences ${\mathcal{M}}^{0}$ and ${\mathcal{M}}^{1}$ to ${\sf Ch}$ receiving cumulative ciphertext $\mathtt{ct}_{1}$ and master public key $\mathtt{mpk}$.

Then, for $i=1,\ldots,n$, ${\cal B}$ computes $\mathtt{c}_{1,i}$ as $\mathtt{c}_{1,i}=\mathsf{SYM}.{\mathsf{enc}}(M_{i},0)$. The pair $(\mathtt{ct}_{1},\mathtt{c}_{1})$ where $\mathtt{c}_{1}=(\mathtt{c}_{1,1},\ldots,\mathtt{c}_{1,n})$ constitutes the simulated encryption of the first element of the stream. ${\cal B}$ then computes the encryption of all the remaining rows by executing the encryption algorithm ${\mathsf{Encrypt}}$ using public key $\mathtt{mpk}$.

All the ciphertexts obtained $(\mathtt{ct}_{1},\mathtt{c}_{1}),\cdots,(\mathtt{ct}_{m},\mathtt{c}_{m})$ are then sent to ${{\cal A}}$.

Answering queries. Whenever ${{\cal A}}$ issues an access request ${\mathsf{AccReq}}=((\mathtt{Pol},k),\mathtt{id}\mathtt{Q},\mathtt{id}\mathtt{P})$, ${\cal B}$ proceeds as follows.

If $\mathtt{id}\mathtt{Q}\in\mathsf{C}$ then ${\cal B}$ issues an ${\mathsf{m}{\mathsf{KeyGen}}}$ request to ${\sf Ch}$ for $(\mathtt{Pol},k)$ constructing a vector of attributes of length $u+v=n+3$ as done by algorithm ${\mathsf{AuthorizeDec}}$. The $\mathtt{m}\mathtt{Tok}$ obtained from ${\sf Ch}$ is then passed to ${{\cal A}}$. If $\mathtt{id}\mathtt{Q}\in\mathsf{C}$ or $\mathtt{id}\mathtt{P}\in\mathsf{C}$ then ${\cal B}$ issues a ${\mathsf{p}{\mathsf{KeyGen}}}$ request to ${\sf Ch}$ for $\mathtt{Pol}$ constructing a vector of attributes of length $u=n+1$ as done by algorithm ${\mathsf{AuthorizeSel}}$. The $\mathtt{p}\mathtt{Tok}$ obtained from ${\sf Ch}$ is then passed to ${{\cal A}}$.

The following remarks are in order. First of all, we observe that ${\cal B}$ is an admissible adversary for $\mathsf{AOE}$ as all tokens it requests to ${\sf Ch}$ give the same result independently from whether ${\sf Ch}$ has encrypted using the ${\mathcal{X}}^{0}$ or ${\mathcal{X}}^{1}$. Indeed ${\cal B}$ asks only for tokens that are seen by corrupted players and, by the admissibility of ${{\cal A}}$, they provide the same results when applied to the two challenges. Also, observe that the view of ${{\cal A}}$ as constructed by ${\cal B}$ is not the same as in the security game for $\mathsf{SSS}$. Indeed the symmetric ciphertexts corresponding to the row of the first component of the stream are encryptions of [math] (and not of the elements of $\mathtt{Row}^{0}_{1}$ or $\mathtt{Row}^{1}_{1}$ as in the real view). However, we observe that the two views are indistinguishable by the IND-CPA security of $\mathsf{SYM}$. Further details are omitted.

We thus have the following theorem.

Theorem 2

If $\mathsf{AOE}$ is game-based secure and $\mathsf{SYM}$ is IND-CPA secure then $\mathsf{SSS}$ is game-based secure.

3.5 $\mathbb{CONJ}$ is invertible

In this section we show that the set of policies $\mathbb{CONJ}$ is invertible by providing an implementation of the algorithm ${\mathsf{ConstAdm}}$. This, together with Theorem 2 above and Theorem 1, gives the following theorem.

Theorem 3

If $\mathsf{AOE}$ is game-based secure and $\mathsf{SYM}$ is IND-CPA secure then $\mathsf{SSS}$ is simulation-based secure.

Algorithm ${\mathsf{ConstAdm}}$ takes as input a set of full positive constraints $\mathtt{ctr}^{\text{f}}=(\mathtt{ctr}^{\text{f}}_{1},\ldots,\mathtt{ctr}^{\text{f}}_{\mathtt{flen}})$, a set of positive constraints $\mathtt{ctr}^{+}=(\mathtt{ctr}^{+}_{1},\ldots,\mathtt{ctr}^{+}_{\mathtt{plen}})$, and a set of negative constraints $\mathtt{ctr}^{-}=(\mathtt{ctr}^{-}_{1},\ldots,\mathtt{ctr}^{-}_{\mathtt{nlen}})$. Every policy $\mathtt{Pol}\in(\mathtt{ctr}^{+}\cup\mathtt{ctr}^{-})$ is composed of $n$ elements $\mathtt{Pol}_{1},\ldots,\mathtt{Pol}_{n}\in\mathbb{Z}_{p}$, where each element is a string for the equality comparison or a don’t care symbol $\star$. The goal of the algorithm is to build a row $\mathtt{Row}=(\mathtt{Row}_{1},\ldots,\mathtt{Row}_{n})$ that is admissible with respect to all constraints of $\mathtt{ctr}^{\text{f}}\cup\mathtt{ctr}^{+}\cup\mathtt{ctr}^{-}$.

Firstly, ${\mathsf{ConstAdm}}$ instantiates an empty row $\mathtt{Row}=(\mathtt{Row}_{1},\ldots,\mathtt{Row}_{n}$) and, for all pairs $k,\mathtt{val}\in\mathtt{ctr}^{\text{f}}$, sets $\mathtt{Row}_{k}=\mathtt{val}$. Then, it solves a system of $\mathtt{plen}$ linear equations where each equation is of the form

[TABLE]

with $\mathtt{Pol}\in\mathtt{ctr}^{+}$. We note that the system has at a least one solution, because we know that exists a row complying with those constraints. Now, if $n<=\mathtt{plen}$, the algorithm returns $\mathtt{Row}$. Otherwise, we have $d=n-\mathtt{plen}$ cells in the system that can be freely set and are only dependent on the other cells. The procedure picks these cells at random in $\{1,2^{\lambda}\}$. Then, it checks if all the following inequalities

[TABLE]

where $\mathtt{Pol}\in\mathtt{ctr}^{-}$, are satisfied. If not, it picks the random values again, until the inequalities are satisfied. We note that only with negligible $d/2^{\lambda}$ probability the inequalities are not satisfied and the algorithm needs to pick random values again. Finally, the procedure ${\mathsf{ConstAdm}}$ returns $\mathtt{Row}$.

4 Constructing $\mathsf{AOE}$

In this section we describe an $\mathsf{AOE}$ scheme with attribute from $\mathbb{Z}_{p}$, for some large $p$, and messages from $\mathbb{G}_{T}$ and prove that, under hardness assumptions in bilinear setting, the construction satisfies the security property of Definition 10.

We start by formally describing the 6 algorithms defining an $\mathsf{AOE}$.

${\mathsf{ParGen}}(1^{\lambda},1^{n},1^{u},1^{v})$ algorithm. The algorithm starts by randomly selecting a bilinear mapping $(\mathbb{G},\mathbb{G}_{T},p,\mathbf{e})$ with security parameter $\lambda$. Then it randomly selects $\omega,\alpha_{1},\alpha_{2},\beta_{1},\beta_{2}\in\mathbb{Z}_{p}$ and constructs $n+1$ pairs of basic master secret keys $((\mathtt{bmsk}^{1}_{0},\mathtt{bmsk}^{2}_{0}),\ldots,(\mathtt{bmsk}^{1}_{n},\mathtt{bmsk}^{2}_{n}))$. The two basic master secret keys in the first pair consist of $u+1$ quadruples $\mathtt{bmsk}^{b}_{0}=(\gamma_{i,b,0},\delta_{i,b,0},\theta_{i,b,0},\omega_{i,b,0})_{i=1}^{u+1}$, for $b=1,2$ and, the reamining $n$ pairs, for $j=1,\ldots,n$ and $b=1,2$ $\mathtt{bmsk}^{b}_{j}=(\gamma_{i,b,j},\delta_{i,b,j},\theta_{i,b,j},\omega_{i,b,j})_{i=1}^{v+1}$ have length $v+1$. All components are randomly selected in $\mathbb{Z}_{p}$ subject to $\alpha_{1}\cdot\theta_{i,1,j}-\beta_{1}\cdot\omega_{i,1,j}=\omega$ and $\alpha_{2}\cdot\theta_{i,2,j}-\beta_{2}\cdot\omega_{i,2,j}=\omega$. The master secret key $\mathtt{msk}$ is then set equal to

[TABLE]

where $g,g_{2}$ are randomly selected in $\mathbb{G}$ and $\Lambda=\mathbf{e}(g,g_{2})$. The basic master public keys $\mathtt{bmpk}^{1}_{0}$ and $\mathtt{bmpk}^{2}_{0}$ are

[TABLE]

[TABLE]

and, for $j=1,\ldots,n$,

[TABLE]

[TABLE]

The master public key $\mathtt{mpk}$ is then computed by setting $\Omega=g^{\omega}$ and then seting

[TABLE] 2. 2.

${\mathsf{Enc}}(\mathtt{mpk},{\mathcal{X}},{\mathcal{M}})$ algorithm. The encryption algorithm takes as input the master public key $\mathtt{mpk}$, a sequence of vectors of attributes ${\mathcal{X}}=(X_{0},\ldots,X_{n})$ and a sequence ${\mathcal{M}}=(M_{1},\ldots,M_{n})$ of messages. Vector $X_{0}$ has length $u$, whereas the others have length $v$. The encryption algorithm produces one cumulative ciphertext $\mathtt{ct}$ consisting of $n+1$ basic ciphertexts $\mathtt{ct}_{0},\ldots,\mathtt{ct}_{n}$. The encryption algorithm starts by selecting random $y,z_{1},z_{2}\in\mathbb{Z}_{p}.$ The value $s$ is used to extend the vectors of attributes; specifically, the algorithm considers the vectors $(X_{0},y)$ and $(y,X_{j})$ for $j>0$. We denote by $x_{i,0}$ the $i$-th component of $(X_{0},y)$ and, similarly, by $x_{i,j}$ the $i$-th component of $(y,X_{j})$. The algorithm also extends the sequence of messages by setting $M_{0}=1_{\mathbb{G}_{T}}$. Basic ciphertext $\mathtt{ct}_{j}$, for $j=0,\ldots,n$, is computed by first randomly selecting $l_{j},q_{j}\in\mathbb{Z}_{p}$ and setting

[TABLE]

and then by setting

[TABLE]

where $i$ goes from $1$ to $u+1$, for $j=0$; and to $v+1$ for $j>0$. 3. 3.

${\mathsf{m}{\mathsf{KeyGen}}}(\mathtt{msk},S_{0},S_{k},k)$ algorithm. The algorithm for generating a message token takes as input the master secret key $\mathtt{msk}$, a vector of attributes $S_{0}$ of length $u$, a vector of attributes $S_{k}$ of length $v$, and integer $k\in\{1,\ldots,n\}$. The algorithm uses the basic master keys for $j=0$ and $j=k$ to generate the message token for $(S_{0},S_{k},k)$. Instead of considering them separately, it is useful to see $\mathtt{bmsk}_{0}^{1}$ and $\mathtt{bmsk}_{k}^{1}$ as one basic master key of length $f:=(u+1)+(v+1)$ obtained by concatenation and denote its $i$-th component $(\gamma_{i,1},\delta_{i,1},\theta_{i,1},\omega_{i,1})$. Similarly, $\mathtt{bmsk}_{0}^{2}$ and $\mathtt{bmsk}_{k}^{2}$ yield a basic master secret key of length $f$ whose $i$-th component is the quadruple $(\gamma_{i,2},\delta_{i,2},\theta_{i,2},\omega_{i,2})$. The algorithm constructs vector of attributes $S=(S_{0},1,-1,S_{k})$ of length $f$ and we denote by $s_{i}$ its $i$-th component. The algorithm starts by selecting random $\lambda_{1},\lambda_{2}\in\mathbb{Z}_{p}$. Then, for $i=1,\ldots,f$, the algorithm randomly selects $r_{i,1},r_{i,2}\in\mathbb{Z}_{p}$ and sets

[TABLE]

The algorithm returns message token $\mathtt{m}\mathtt{Tok}=(F,H,(K_{i,1},L_{i,1},K_{i,2},L_{i,2})_{i=1}^{f})$, where

[TABLE]

and

[TABLE] 4. 4.

${\mathsf{p}{\mathsf{KeyGen}}}(\mathtt{msk},S)$ algorithm. The algorithm for generating a predicate token takes as input the master secret key $\mathtt{msk}$ and a vector of attributes $S$ of length $u$. Vector $S$ is extended to length $u+1$ by appending [math]. The algorithm starts by selecting random $\lambda_{1},\lambda_{2}\in\mathbb{Z}_{p}$. Then, for $i=1,\ldots,u+1$, the algorithm randomly selects $r_{i,1},r_{i,2}\in\mathbb{Z}_{p}$ and sets

[TABLE]

The algorithm returns predicate token

$\mathtt{p}\mathtt{Tok}=(F,H,(K_{i,1},L_{i,1},K_{i,2},L_{i,2})_{i=1}^{u+1})$, where

[TABLE]

and

[TABLE] 5. 5.

Decryption algorithms. Algorithm ${\mathsf{p}{\mathsf{Dec}}}$ takes as input ciphertext $\mathtt{ct}_{0}=(A_{0},B_{0},C_{0},\allowbreak(D_{i,1},E_{i,1},D_{i,2},E_{i,2})_{i=1}^{u+1})$ and $\mathtt{p}\mathtt{Tok}=(F,H,(K_{i,1},L_{i,1},K_{i,2},L_{i,2})_{i=1}^{u+1})$ and consists in testing whether the following product is equal to $1_{\mathbb{G}_{T}}$

[TABLE]

Algorithm ${\mathsf{m}{\mathsf{Dec}}}$ takes as input $\mathtt{ct}_{0},\mathtt{ct}_{k}$ and an M-token $\mathtt{m}\mathtt{Tok}$ for $k$. By setting $f:=(u+1)+(v+1)$ we can write $\mathtt{m}\mathtt{Tok}$ as

[TABLE]

and, with a slight abuse of notation, we can write

[TABLE]

The decryption algorithm returns $M$ computed as

[TABLE]

where $C=C_{0}\cdot C_{k}$, $A=A_{0}\cdot A_{k}$ and $B=B_{0}\cdot B_{k}.$

4.1 Correctness of the construction

We show the correctness of the decryption algorithm for P-token in the following. We denote by $\mathtt{bmsk}_{0,1}$ and $\mathtt{bmsk}_{0,2}$ the two basic master secret keys used to compute both $\mathtt{p}\mathtt{Tok}$ and $\mathtt{ct}_{0}$ and we denote the $i$-th element of $\mathtt{bmsk}_{0,1}$ by $(\gamma_{i,1},\delta_{i,1},\theta_{i,1},\omega_{i,1})$ and the $i$-th element of $\mathtt{bmsk}_{0,2}$ by $(\gamma_{i,2},\delta_{i,2},\theta_{i,2},\omega_{i,2})$. We observe that, for $i=1,\ldots,u+1$, we have

[TABLE]

and simple manipulations show that the product above is

[TABLE]

Similarly, we have

[TABLE]

and therefore

[TABLE]

is equal to

[TABLE]

On the other hand, we have

[TABLE]

Therefore if $\langle X,S\rangle=0$ we have that the above product is equal to $\mathbf{e}(g,g_{2})^{q_{0}}=C_{0}^{-1}$. On the other hand, if $\langle X,S\rangle\neq 0$ then the above product is a random element of $\mathbb{G}_{T}$.

The decryption algorithm for an M-token is similar to the one for the P-token and can be thus omitted.

4.2 Security of the construction

In this section, we show that the $\mathsf{AOE}$ construction guarantees the security of the attributes and of the plaintexts of a cumulative ciphertext.

Observe that the encryption algorithm ${\mathsf{Enc}}$ can be seen as computing a pair of basic ciphertexts: one consisting of the $D_{i,1,j}$ and $E_{i,1,j}$ and one consisting of the $D_{i,2,j}$ and $E_{i,2,j}$. The same sequence of vectors of attributes is used for each basic ciphertext. In the hybrid games we will consider for the security proof, this will not be necessarily the case as, in some cases, we will produce challenge ciphertexts consisting of two basic ciphertexts computed with respect to two different sequences of vectors of attributes. Specifically, if ${\mathcal{X}}^{0}=(X_{0}^{0},\ldots,X_{n}^{0})$ and ${\mathcal{X}}^{1}=(X_{0}^{1},\ldots,X_{n}^{1})$ are two sequences of vectors of attributes then when we say that the sequence of messages ${{\mathcal{M}}}=(M_{1},\ldots,M_{n})$ is encrypted with respect to $({\mathcal{X}}^{0},{\mathcal{X}}^{1})$, we actually mean that the first basic ciphertext is with respect to ${\mathcal{X}}^{0}$ and the second with respect to ${\mathcal{X}}^{1}$.

The proof uses hybrid games parameterized by $(\lambda,n,u,v)$ and by a probabilistic polynomial-time algorithm ${\cal A}$. The hybrids differ in the way the challenge ciphertext is computed and are summarized in the following table. There ${\mathcal{X}}^{0}$ and ${\mathcal{X}}^{1}$ are the two attribute sequences of length $n+1$ and ${{\mathcal{M}}}^{0}$ and ${{\mathcal{M}}}^{1}$ are the two sequences of $n$ messages given in output by ${\cal A}$. We let ${\mathcal{Z}}$ denote the attribute sequence in which all attribute vectors are zeros; that is, ${{\mathcal{Z}}}=(0^{u},0^{v},\ldots,0^{v})$.

[TABLE]

We stress that the first game, $\mathsf{\mathsf{AOE}Game}_{0}^{\cal A}$, coincides with the security game $\mathsf{\mathsf{AOE}Game}^{\cal A}$ in which the challenger ${\sf Ch}$ sets $\xi=0$ and the last game, $\mathsf{\mathsf{AOE}Game}_{6}^{\cal A}$, coincides with the security game $\mathsf{\mathsf{AOE}Game}^{\cal A}$ in which the challenger ${\sf Ch}$ sets $\xi=1$.

Indistinguishability of $\mathsf{\mathsf{AOE}Game}_{0}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{1}^{\cal A}$ is proved under the BDDH Assumption. The proof consists in the construction of a probabilistic polynomial-time simulator $\mathcal{B}_{1}$ that interacts with a probabilistic polynomial-time adversary ${\cal A}$ and receives a sequence ${\mathcal{X}}$ of vectors of attributes, a sequence of messages ${\mathcal{M}}$, and a challenge $({\mathbb{B}},g,T_{1},T_{2},T_{3},T)$ for the BDDH Assumption. Simulator $\mathcal{B}_{1}$ simulates an interaction with ${\cal A}$ in which the challenge ciphertext, depending on the value $\xi$ hidden in the challenge received, is an encryption of the messages in sequence ${{\mathcal{M}}}$ with attributes vectors ${\mathcal{X}}$ or an encryption of random messages with attributes vectors ${\mathcal{X}}$. By considering $\mathcal{B}_{1}$ with ${{\mathcal{X}}}:={{\mathcal{X}}}^{0}$ and ${{\mathcal{M}}}:={{\mathcal{M}}}^{0}$ gives that, under the BDDH Assumption, $\mathsf{\mathsf{AOE}Game}_{0}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{1}^{\cal A}$ are indistinguishable. Instead, for indistinguishability of $\mathsf{\mathsf{AOE}Game}_{5}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{6}^{\cal A}$ we set ${{\mathcal{X}}}:={{\mathcal{X}}}^{1}$ and ${{\mathcal{M}}}:={{\mathcal{M}}}^{1}.$

The remaining hybrids are proved indistinguishable under the BDL Assumption. Specifically, we construct a probabilistic polynomial-time simulator $\mathcal{B}_{2}$ that interacts with a probabilistic polynomial-time adversary ${\cal A}$ and receives a challenge $({\mathbb{B}},g,T_{1},T_{2},T_{13},T_{4},T)$ for the BDL Assumption. As additional inputs, $\mathcal{B}_{2}$ receives two sequences of attribute vectors ${\mathcal{X}}$ and ${\mathcal{V}}$. $\mathcal{B}_{2}$, depending on the value $\xi$ hidden by the challenge received, simulates a game in which a randomly chosen sequence of messages is encrypted either with respect to sequences of attributes $({{\mathcal{X}}},{{\mathcal{Z}}})$ or with respect to sequences of attributes $({{\mathcal{X}}},{{\mathcal{V}}})$. Then $\mathsf{\mathsf{AOE}Game}_{1}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{2}^{\cal A}$ are proved indistinguishable by running $\mathcal{B}_{2}$ on sequences ${{\mathcal{X}}}:={{\mathcal{X}}}^{0}$ and ${{\mathcal{V}}}:={{\mathcal{X}}}^{0}$. To prove indistinguishability of $\mathsf{\mathsf{AOE}Game}_{2}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{3}^{\cal A}$, $\mathcal{B}_{2}$ is run on sequences ${{\mathcal{X}}}:={{\mathcal{X}}}^{0}$ and ${{\mathcal{V}}}:={{\mathcal{X}}}^{1}$. To prove indistinguishability of $\mathsf{\mathsf{AOE}Game}_{3}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{4}^{\cal A}$, and $\mathsf{\mathsf{AOE}Game}_{4}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{5}^{\cal A}$, we use a mirror image of $\mathcal{B}_{2}$ (that we call $\mathcal{B}_{2}^{\prime}$) that, depending on the value $\xi$ hidden by the challenge received, encrypts a randomly chosen sequence of messages either with respect to sequences of attributes $({{\mathcal{Z}}},{{\mathcal{X}}})$ or with respect to sequences of attributes $({{\mathcal{V}}},{{\mathcal{X}}})$. Thus, to prove indistinguishability of $\mathsf{\mathsf{AOE}Game}_{3}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{4}^{\cal A}$, $\mathcal{B}_{2}^{\prime}$ is run on sequences ${{\mathcal{X}}}:={{\mathcal{X}}}^{1}$ and ${{\mathcal{V}}}:={{\mathcal{X}}}^{0}$ and to prove indistinguishability of $\mathsf{\mathsf{AOE}Game}_{4}^{\cal A}$ and $\mathsf{\mathsf{AOE}Game}_{5}^{\cal A}$, $\mathcal{B}_{2}^{\prime}$ is run on sequences ${{\mathcal{X}}}:={{\mathcal{X}}}^{1}$ and ${{\mathcal{V}}}:={{\mathcal{X}}}^{1}$.

4.2.1 Simulators

Simulators $\mathcal{B}_{1}$ and $\mathcal{B}_{2}$ are described in the following. The description of $\mathcal{B}_{2}^{\prime}$ can be obtained by modifying $\mathcal{B}_{2}$ in a straightforward way and is thus omitted.

Simulator $B_{1}$.

It takes as input a challenge $(g,T_{1}=g^{t_{1}},T_{2}=g^{t_{2}},T_{3}=g^{t_{3}},T=\mathbf{e}(g,g)^{t_{1}t_{2}t_{3}+\xi\cdot r})$ for the BDDH assumption along with a sequence ${\mathcal{M}}=(M_{1},\ldots,M_{n})$ of messages and a sequence ${\mathcal{X}}=(X_{0},X_{1},\ldots,X_{n})$ of vectors of attributes. $\mathcal{B}_{1}$ interacts with adversary ${\cal A}$ and, depending on whether $\xi=0$ or $\xi=1$, simulates $\mathsf{\mathsf{AOE}Game}^{\cal A}(\lambda,n,u,v)$ in which the challenge ciphertext is an encryption with attributes ${\mathcal{X}}$ of $n$ random elements of $\mathbb{G}_{T}$ or of the messages in ${\mathcal{M}}$.

Constructing $\mathtt{mpk}$ and a partial $\mathtt{msk}$. The master secret key contains $(n+1)$ pairs of basic master secret keys $(\mathtt{bmsk}_{j}^{1},\mathtt{bmsk}_{j}^{2})$. We let $\ell_{j}$ denote the length of the basic master secret keys of the $j$-th pair and write $\mathtt{bmsk}_{j}^{1}=(\gamma_{i,1,j},\delta_{i,1,j},\theta_{i,1,j},\omega_{i,1,j})_{i=1}^{\ell_{j}}$ and $\mathtt{bmsk}_{j}^{2}=(\gamma_{i,2,j},\delta_{i,2,j},\theta_{i,2,j},\omega_{i,2,j})_{i=1}^{\ell_{j}}$. Clearly, $\ell_{0}=u+1$ and $\ell_{j}=v+1$ for $j>0$.

$\mathcal{B}_{1}$ starts by randomly selecting $\rho_{0},\ldots,\rho_{n}\in\mathbb{Z}_{p}$ and $\alpha_{1},\alpha_{2},\beta_{1},\beta_{2},\omega,y\in\mathbb{Z}_{p}$. We let $x_{i,0}$ denote the $i$-th component of the vector $(X_{0},y)$ of length $u+1$; and, for $j>0$, we let $x_{i,j}$ denote the $i$-th component of the vector $(y,X_{j})$ of length $v+1$.

For $i=1,\ldots,\ell_{j}$, $b=1,2$, and $j=0,\ldots,n$, $\mathcal{B}_{2}$ picks random $\tilde{\gamma}_{i,b,j},\tilde{\delta}_{i,b,j},\theta_{i,b,j},\omega_{i,b,j}\in\mathbb{Z}_{p}$ subject to

[TABLE]

$\mathcal{B}_{1}$ computes the basic master secret keys in such way to implicitly set

[TABLE]

It is easy to verify that the values are independent and uniformly distributed in $\mathbb{Z}_{p}$. Clearly, the values $\gamma_{i,b,j}$ and $\delta_{i,b,j}$ cannot be explicitly computed by $\mathcal{B}_{1}$ but it is easy to see that $\Gamma_{i,b,j}=g^{\gamma_{i,b,j}}$ and $\Delta_{i,b,j}=g^{\delta_{i,b,j}}$ can be computed by setting

[TABLE]

and, obviously, $W_{i,b,j}=g^{\omega_{i,b,j}}$ and $\Theta=g^{\theta_{i,b,j}}$, for all $i,b$ and $j$. Finally, $\mathcal{B}_{1}$ sets $\Omega=g^{\omega}$ and, instead of setting $\Lambda=\mathbf{e}(g,g_{2})$, picks a random $\eta\in\mathbb{Z}_{p}$ and sets $\Lambda=\mathbf{e}(T_{1},T_{2})^{\omega}\cdot\mathbf{e}(g,g)^{\eta}$. The value of $g_{2}$ is thus implicitly set equal to $g^{\eta+\omega\cdot t_{1}\cdot t_{2}}.$

Answering token queries. We next describe how $\mathcal{B}_{1}$ answers M-token queries for $(S_{0},S_{k},k)$. P-token queries for vector $S_{0}$ are simpler and can be handled similarly. We remind the reader that an M-token is computed by constructing the vector $(S_{0},1,-1,S_{k})$ of length $f:=(u+1)+(v+1)$ whose $i$-th component will be denoted by $s_{i}$. For the sake of a more agile notation, we will collapse corresponding values from $\mathtt{bmsk}_{0}$ and $\mathtt{bmsk}_{d}$ into one single vector of length $f$. For example, instead of considering vectors $(\omega_{i,1,0})_{i=1}^{u+1}$ and $(\omega_{i,1,d})_{i=1}^{v+1}$ as two separate vectors, we will consider the vector of length $f$ obtained by concatenating them and denote by $\omega_{i,1}$ its $i$-th component. Similarly, for $\omega_{i,2},\theta_{i,1},\theta_{i,2},\tilde{\gamma}_{i,1},\tilde{\gamma}_{i,2},\gamma_{i,1},\gamma_{i,2},\tilde{\delta}_{i,1},\tilde{\delta}_{i,2},\delta_{i,1},$ and $\delta_{i,2}$.

$\mathcal{B}_{1}$ sets $c=2\cdot\left(\langle X_{0},S_{0}\rangle/\rho_{0}+\langle X_{k},S_{k}\rangle/\rho_{k}\right)$, randomly selects $\tilde{\lambda}_{1},\tilde{\lambda}_{2}\in\mathbb{Z}_{p}$ and returns a token with the same distribution as the token returned by ${\mathsf{m}{\mathsf{KeyGen}}}$ with randomness

[TABLE]

Observe that, since $\langle(X_{0},X_{k}),(S_{0},S_{k})\rangle\neq 0$ and $\rho_{0}$ and $\rho_{k}$ are random in $\mathbb{Z}_{p}$, the probability that $c=0$ is negligible. Moreover, if $c\neq 0$, $\lambda_{1}$ and $\lambda_{2}$ are independent and uniform in $\mathbb{Z}_{p}$.

Specifically, for $i=1,\ldots,f$, $\mathcal{B}_{1}$ randomly selects $r_{i,1},r_{i,2}\in\mathbb{Z}_{p}$ and sets

[TABLE]

As the values $r_{i,1},r_{i,2}$ are known to $\mathcal{B}_{1}$ for all $i$, $H$ can be computed in a straightforward way. The computation of $F$ requires some more care. Given $K_{i,1},K_{i,2}$ and $L_{i,1},L_{i,2}$ and $\gamma_{i,1}$ and $\delta_{i,1}$, $F$ is expected to be equal to $g_{2}\cdot\prod_{i=1}^{f}K_{i,1}^{-\gamma_{i,1}}\cdot L_{i,1}^{-\delta_{i,1}}\cdot K_{i,2}^{-\gamma_{i,2}}\cdot L_{i,2}^{-\delta_{i,2}}.$ By setting, $\mu_{i}=\rho_{0}$ for $i=1,\ldots,u+1$ and $\mu_{i}=\rho_{k}$ for $i=u+2,\ldots,f$, and, for $i=1,\ldots,f$ and $b=1,2$,

[TABLE]

we can we write

[TABLE]

Also, observe that, by definition of $c$, we have that

[TABLE]

and therefore the exponent of $g^{t_{1}t_{2}}$ in the expression above is equal to $-\omega.$ Now, by recalling that $g_{2}$ has been implicitly set equal to $g_{2}=g^{\eta+\omega\cdot t_{1}\cdot t_{2}}$, $F$ is expected to have value

[TABLE]

and $\mathcal{B}_{1}$ has all it is required to compute $F$ according to the expression above.

Preparing the challenge ciphertexts. $\mathcal{B}_{1}$ randomly picks $\tilde{z}_{1},\tilde{z}_{2}\in\mathbb{Z}_{p}$ and, $\tilde{l}_{j}$, for $j=0,\ldots,n$. $\mathcal{B}_{1}$ prepares the challenge ciphertexts as if they were generated by ${\mathsf{Enc}}$ with randomness $z_{1}=\tilde{z}_{1}-t_{2}\cdot t_{3},z_{2}=\tilde{z}_{2}-t_{2}\cdot t_{3}$ and, for $j=0,\ldots,n$, $l_{j}=\tilde{l}_{j},q_{j}=\rho_{j}\cdot t_{3}.$ This is obtained by setting $D_{i,b,j}=g^{\tilde{l}_{j}\cdot\omega_{i,b,j}}\cdot T_{3}^{\tilde{\gamma}_{i,b,j}\cdot\rho_{j}}\cdot g^{\alpha_{b}\cdot\tilde{z}_{b}\cdot x_{i,j}}$ and $E_{i,b,j}=g^{\tilde{l}_{j}\cdot\theta_{i,b,j}}\cdot T_{3}^{\tilde{\delta}_{i,b,j}\cdot\rho_{j}}\cdot g^{\beta_{b}\cdot\tilde{z}_{b}\cdot x_{i,j}}.$ Indeed, observe that we can write $D_{i,b,j}$ as

[TABLE]

and, similarly, $E_{i,b,j}$ can be written as

[TABLE]

Finally, for $j=0,\ldots,n$, $\mathcal{B}_{2}$ sets

[TABLE]

and

[TABLE]

Note that the settings above are equivalent to setting $A_{j}=g^{q_{j}}$ and $B_{j}=g^{l_{j}\cdot\omega}$. Let us now look at $C_{j}$. Clearly, if $\xi=1$, then $T$ is random in $\mathbb{G}_{T}$ and the challenge ciphertext constructed by $\mathcal{B}_{1}$ is the cumulative ciphertext of sequence of random messages. Let us consider the case in which $\xi=0$ and thus $T=\mathbf{e}(g,g,)^{t_{1}\cdot t_{2}\cdot t_{3}}$. In this case, $C_{j}$ is expected to have value

[TABLE]

which is exactly the value computed by $\mathcal{B}_{1}$.

Simulator $\mathcal{B}_{2}$.

It takes as input a challenge $(g,T_{1}=g^{t_{1}},T_{2}=g^{t_{2}},T_{13}=g^{t_{1}\cdot t_{3}},T_{4}=g^{t_{4}},T=g^{t_{2}\cdot(t_{3}+t_{4})+\xi\cdot r})$ for the Bilinear Decision Linear assumption and two sequences of vectors of attributes ${{\mathcal{X}}}=(X_{0},X_{1},\ldots,X_{n})$, ${{\mathcal{V}}}=(V_{0},V_{1},\ldots,V_{n})$. We remind the reader that $X_{0}$ and $V_{0}$ have length $u$ and $X_{i}$ and $V_{i}$ have length $v$, for $i=1,\ldots,n$. Simulator $\mathcal{B}_{2}$ interacts with adversary ${\cal A}$ and, depending on whether $\xi=0$ or $\xi=1$, simulates $\mathsf{\mathsf{AOE}Game}^{\cal A}(\lambda,n,u,v)$ in which the challenge ciphertext is the encryption of $n$ random elements of $\mathbb{G}_{T}$ with attributes $({{\mathcal{X}}},{{\mathcal{Z}}})$ or $({{\mathcal{X}}},{{\mathcal{V}}})$ .

$\mathcal{B}_{2}$ starts by randomly selecting $\rho_{0},\ldots,\rho_{n}\in\mathbb{Z}_{p}$ and $\alpha_{1},\alpha_{2},\beta_{1},\beta_{2},\tilde{\omega},y\in\mathbb{Z}_{p}$. We let $x_{i,0}$ denote the $i$-th component of the vector $(X_{0},y)$ of length $u+1$; and, for $j>0$, we let $x_{i,j}$ denote the $i$-th component of the vector $(y,X_{j})$ of length $v+1$. Similarly for $v_{i,j}$.

Constructing $\mathtt{mpk}$ and a partial $\mathtt{msk}$. We next show how $\mathcal{B}_{2}$ determines the basic master secret keys. For $i=1,\ldots,\ell_{j}$, $b=1,2$, and $j=0,\ldots,n$, $\mathcal{B}_{2}$ picks random $\tilde{\gamma}_{i,b,j},\tilde{\delta}_{i,b,j},\tilde{\theta}_{i,b,j},\tilde{\omega}_{i,b,j}\in\mathbb{Z}_{p}$ subject to

[TABLE]

$\mathcal{B}_{2}$ computes the basic master secret keys in such way to implicitly set $\gamma_{i,1,j}=\tilde{\gamma}_{i,1,j}$ and $\delta_{i,1,j}=\tilde{\delta}_{i,1,j}$, $\gamma_{i,2,j}=\alpha_{2}\cdot v_{i,j}\cdot t_{2}/\rho_{j}+\tilde{\gamma}_{i,2,j}$ and $\delta_{i,2,j}=\beta_{2}\cdot v_{i,j}\cdot t_{2}/\rho_{j}+\tilde{\delta}_{i,2,j}$ and

[TABLE]

It is easy to verify that the exponents are independently and uniformly distributed over $\mathbb{Z}_{p}$. Clearly, $\mathcal{B}_{2}$ can only partially compute the basic master secret keys (as they involve values from the Decision Linear challenge tuple). The master public key instead can be computed by the following settings.

[TABLE]

Simple computation shows that the settings above are compatible with the implicit settings of the master secret key. Moreover, we note that, for $j=0,\ldots,n$, $b=1,2$ and $i=1,\ldots,\ell_{j}$, we have

[TABLE]

where $\chi_{i,j}$ is $x_{i,j}$ or $v_{i,j}$, depending on whether $b=1$ or $b=2$.

Answering token queries. Let us now describe how $\mathcal{B}_{2}$ constructs the replies to M-token queries for $(S_{0},S_{k},k)$. A P-token is constructed in a similar way. We omit further details. We use the same notation as for simulator $\mathcal{B}_{1}$.

$\mathcal{B}_{2}$ starts by computing $c_{x},c_{w}\in\mathbb{Z}_{p}\setminus\{0\}$ such that

[TABLE]

Notice that if one of the two inner product is [math], so is the other and thus it is always possible to choose $c_{x}$ and $c_{w}$. If both inner products are equal to [math], $\mathcal{B}_{2}$ takes $c_{x}=c_{w}=1$. $\mathcal{B}_{2}$ then picks random $\tilde{\lambda}_{1},\tilde{\lambda}_{2}\in\mathbb{Z}_{p}$ and, for each $i$, random values $\tilde{r}_{i,1},\tilde{r}_{i,2}\in\mathbb{Z}_{p}$ and constructs the values $K_{i,1},L_{i,1},K_{i,2},L_{i,2}$ as if they were computed by ${\mathsf{B}{\mathsf{KeyGen}}}$ with randomness $\lambda_{1}=\tilde{\lambda}_{1}-\frac{\tilde{\lambda}_{2}}{t_{1}}$, $\lambda_{2}=\frac{\tilde{\lambda}_{2}}{t_{1}}$ and, for $i=1,\ldots,f$,

[TABLE]

where $x_{i},v_{i}$ and $s_{i}$ respectively denote the $i$-th component of vectors $(X_{0},y,y,X_{j})$, $(W_{0},y,y,W_{j})$, and $(S_{0},1,-1,S_{j})$ and $\tau_{i}=t_{2}/\rho_{0}$ for $i=1,\ldots,u+1$ and $\tau_{i}=t_{2}/\rho_{j}$ for $i=u+2,\ldots,f$. Simple computation shows that $K_{i,1},L_{i,1},K_{i,2},L_{i,2}$ can be computed in the following way

[TABLE]

where, for $i=1,\ldots,u+1$ and for $b=1,2$, we set

[TABLE]

for $i=u+2,\ldots,f$ and for $b=1,2$, we set

[TABLE]

Let us now show how $\mathcal{B}_{2}$ computes the two remaining values $F$ and $H$. As far as $H$ is concerned, we observe that each $i$ contributes the factor $g^{-(\tilde{r}_{i,1}+\tilde{r}_{i,2})}$ and that

[TABLE]

where we have used Equation 2. Therefore $H$ can be computed by multiplying, for all $i$, the factors $g^{r_{i,1}}\cdot T_{1}^{r_{i,2}}$. Let us now concentrate on $F$. Each $i$ contributes to $F$ the factor $K_{i,1}^{-\gamma_{i,1}}\cdot L_{i,1}^{-\delta_{i,1}}\cdot K_{i,2}^{-\gamma_{i,2}}\cdot L_{i,2}^{-\delta_{i,2}}$ and note that $\gamma_{i,1}$ and $\delta_{i,1}$ are known to $\mathcal{B}_{2}$. We next show that $\mathcal{B}_{2}$ can compute the remaining component. Indeed, $\mathcal{B}_{2}$ needs to compute

[TABLE]

but notice that the unknown, to $\mathcal{B}_{2}$, term $T_{1}^{\tau_{2}}$ cancels out leaving only terms that can be computed using quantities available to $\mathcal{B}_{2}$. This completes the description of how $\mathcal{B}_{2}$ answers token queries.

Preparing the challenge ciphertexts. We remind the reader that, for $j=0,\ldots,n$, the challenge ciphertext consists of $A_{j},B_{j},C_{j}$ and a pair $(\mathtt{ct}_{1,j},\mathtt{ct}_{2,j})$ of basic ciphertexts each consisting of $\ell_{j}$ pairs of elements. More precisely, we write $\mathtt{ct}_{1,j}=(D_{i,1,j},E_{i,1,j})_{i=1}^{\ell_{j}}$ and $\mathtt{ct}_{2,j}=(D_{i,2,j},E_{i,2,j})_{i=2}^{\ell_{j}}.$ Let us now describe how the pair of basic ciphertexts is computed. $\mathcal{B}_{2}$ randomly picks $\tilde{z}_{1},\mu_{0},\ldots,\mu_{n}\in\mathbb{Z}_{p}$ and computes the $j$-th pair of basic ciphertexts as if output by the ${\mathsf{Enc}}$ algorithm with randomness $l_{j}=t_{3}\cdot\rho_{j}$ and $q_{j}=t_{4}\cdot\rho_{j}+\mu_{j}$ and

[TABLE]

Notice that $z_{1}$ and $z_{2}$ and $l_{j}$’s and $q_{j}$’s are independently and uniformly distributed in $\mathbb{Z}_{p}$.

For each $j$, $\mathcal{B}_{2}$ sets $A_{j}=T_{4}^{\rho_{j}}\cdot g^{\mu_{j}}=g^{t_{4}\cdot\rho_{j}+\mu_{j}}=g^{q_{j}}$, $B_{j}=T_{13}^{\rho_{j}\cdot\omega}=g^{\tilde{\omega}\cdot t_{3}\cdot\rho_{j}}=g^{l_{j}\cdot\tilde{\omega}}$ and randomly selects $C_{j}$ at random in $\mathbb{G}_{T}$. The components, $D_{i,1,j}$ and $E_{i,1,j}$, of the first basic ciphertext are computed as

[TABLE]

Simple algebraic manipulations, similar to the ones used for $D_{i,1,j}$, show that $E_{i,1,j}=g^{l_{j}\cdot\theta_{i,1,j}}\cdot g^{q_{j}\cdot\delta_{i,1,j}}\cdot g^{z_{1}\cdot\beta_{1}\cdot x_{i,j}}.$ Therefore $D_{i,1,j}$ and $E_{i,1,j}$ are distributed exactly claimed. The components, $E_{i,2,j}$ and $D_{i,2,j}$, of the second basic ciphertext are computed as

[TABLE]

Simple algebraic manipulations give

[TABLE]

Finally, observe that if $r=0$ the ciphertext produced corresponds to $n$ random messages encrypted with attributes $({\mathcal{X}},{\mathcal{Z}})$. If instead $r$ is random, then $\mathcal{B}_{2}$ has produced the cumulative ciphertext corresponding to $n$ random messages encrypted with attributes $({\mathcal{X}},{\mathcal{V}})$.

5 Experimental evaluation

Our experimental work consists of a complete implementation in C/C++ of our $\mathsf{AOE}$ and of an implementation of our scenario (see Figure 1). We use the MIRACL library222https://github.com/miracl/MIRACL, freely provided by CertiVox (now MIRACL). Our implementation uses a Barreto-Naehrig curve over a 256-bit field [5] that gives a security level equivalent to AES-128. The source code is available at https://github.com/secureselect/SecSel.

We remind the reader that our data is organized as a stream of rows with the same number of cells and that each row is encrypted independently from the other rows, possibly by different DSs. For a stream composed of rows with $m$ columns, we instantiate an $\mathsf{AOE}$ that can encrypt $n:=m$ plaintexts (one for each cell of the row to be encrypted) with $l:=2m+1$ common attributes and $k:=2$ specific attributes. Let us see how $l$ and $k$ are determined by describing the encryption procedure (Step ii of the scenario). Consider a row consisting of $m$ strings $c_{1},\ldots,c_{m}$ (the cells). For $i=1,\ldots,m$, the encryption procedure randomly selects an element $g_{i}$ of the target group $\mathbb{G}_{T}$ and then obtains a 128-bit key $k_{i}$ by hashing the selected element (this is done by using the hash_to_aes_key function of the MIRACL library). Finally, $c_{i}$ is encrypted with AES in CBC mode using $k_{i}$ as a key. The $m$ group elements $g_{1},\ldots,g_{m}$ are then encrypted with our $\mathsf{AOE}$ (remember that the message space of our $\mathsf{AOE}$ implementation coincides with the target group $\mathbb{G}_{T}$). The attributes used to encrypt the $g_{i}$’s are derived from the strings $c_{1},\ldots,c_{m}$ and from the noise $R$. Remember that the attribute space of our $\mathsf{AOE}$ coincides with $\mathbb{Z}_{p}$ ($p$ is the prime order of the bilinear setting used) and thus we first hash each $c_{i}$ to obtain $x_{i}\in\mathbb{Z}_{p}$. The common attributes used to encrypt the cells are obtained from the $m$ integers $x_{1},\ldots,x_{m}$ and from $R$ and they correspond to the values of the monomials that could possibly have a non-zero coefficient in the polynomial resulting from the arithmetization of the predicate corresponding to the queries supported by our system (the arithmetization is, for example, illustrated in [24]). It is straightforward to see that, for every supported query $\cal Q$, the polynomial corresponding to predicate $\mathbb{PP}_{\cal Q}$ has at most $2\cdot m+1$ non-zero terms (i.e., $x_{1},\ldots,x_{m},R$ and $R\cdot x_{1},\ldots,R\cdot x_{m}$). For example, the query ${\cal Q}$ from the previous example that asks for the userId of all patients with fever and nausea with $R^{\prime}=2$ corresponds to polynomial $(R-2)\cdot[r_{5}\cdot(x_{5}-1)+r_{6}\cdot(x_{6}-1)]$ obtained by arithmetizing predicate $\mathbb{PP}_{\cal Q}$, for randomly chosen $r_{5},r_{6}$. This is expanded into a vector of $13=2m+1$ entries with 6 non-zero entries (corresponding to coefficients of $R,x_{5},x_{6}$, of $R\cdot x_{5}$, of $R\cdot x_{6}$ and the zero-degree term). The polynomial corresponding to predicate $\mathbb{PM}_{\cal Q}$ contributes two more terms (the one corresponding to the clause $(i=d)$). Therefore, we have $l=2m+1$ and $k=2$ for a total of $2m+1+2m=4m+1=\Theta(m)$ attributes. Firstly, we provide experimental evidence that $\mathsf{AOE}$ has better performance than (non-amortized) Orthogonality encryption and this justifies the introduction of $\mathsf{AOE}$ as a new primitive. We report below the multiplicative blow-up in time for the encryption function of Orthogonality with respect to $\mathsf{AOE}$ and in space of the Orthogonality ciphertext with respect to the $\mathsf{AOE}$ ciphertext.

[TABLE]

Thus, for rows with $32$ cells $\mathsf{AOE}$ is faster by almost a factor of $3$ and uses $4.5$ times less memory. The gap between the two implementations widens as the number of cells in a row grows. This is expected since, as remarked in the “Efficiency” paragraph of Section I.B, $\mathsf{AOE}$ yields row encryption with linear (in the number of cells) time and space complexity whereas (non-amortized) Orthogonality encryption gives quadratic complexity. We remark that the time needed to encrypt a row does not depend on how similar the cells of the row are.

The aim of the next experiment is to collect data on the time needed by each operation and times must not be considered in absolute terms but only to have an idea of the time needed to process a cell. This is particularly true for encryption as it will be performed by DSs that will likely batch encrypt only a few rows every time. Significant is the running time of the P-token application and this is a direct consequence of the fact that the distributed nature of our scenario does not allow for the option of pre-processing the data before uploading it to the cloud repository. We remark also that it is reasonable to assume that the QP (the party applying the P-token) is the one with the most computing power. Moreover, the fact that the P-token can be applied to each row independently makes it amenable of a highly parallel implementation. The next table reports an estimate of the time per cell in milliseconds for each of the four operations. The time for token generation is the time to generate both tokens.

[TABLE]

6 Conclusions

In this work we have introduce the notion of a Secure Stream Selection scheme $\mathsf{SSS}$. Here a number of potentially untrusted parties can encrypt elements in a stream data that can be selectively decrypted by third parties authorized by a trusted data owner. We give two notions of security, a game-based one and a simulation-based one, that are shown to be equivalent for a class of access policies that include policies of interest for applications.

We give a construction of $\mathsf{SSS}$ on top of Amortized Orthogonality Encryption scheme $\mathsf{AOE}$ that permits the efficient encryption of several data items with respect to sets of attributes that differ in few elements. We have proved that our construction is secure under standard assumptions in a bilinear setting. We have provided an implementation that shows the feasibility and effectiveness of our approach, using the C/C++ MIRACL library.