2 research outputs found

    Permuted Puzzles and Cryptographic Hardness

    Get PDF
    A permuted puzzle problem is defined by a pair of distributions D0,D1D_0,D_1 over SnS^n. The problem is to distinguish samples from D0,D1D_0,D_1, where the symbols of each sample are permuted by a single secret permutation pp of [n][n]. The conjectured hardness of specific instances of permuted puzzle problems was recently used to obtain the first candidate constructions of Doubly Efficient Private Information Retrieval (DE-PIR) (Boyle et al. & Canetti et al., TCC\u2717). Roughly, in these works the distributions D0,D1D_0,D_1 over FnF^n are evaluations of either a moderately low-degree polynomial or a random function. This new conjecture seems to be quite powerful, and is the foundation for the first DE-PIR candidates, almost two decades after the question was first posed by Beimel et al. (CRYPTO\u2700). While permuted puzzles are a natural and general class of problems, their hardness is still poorly understood. We initiate a formal investigation of the cryptographic hardness of permuted puzzle problems. Our contributions lie in three main directions: 1. Rigorous formalization. We formalize a notion of permuted puzzle distinguishing problems, extending and generalizing the proposed permuted puzzle framework of Boyle et al. (TCC\u2717). 2. Identifying hard permuted puzzles. We identify natural examples in which a one-time permutation provably creates cryptographic hardness, based on ``standard\u27\u27 assumptions. In these examples, the original distributions D0,D1D_0,D_1 are easily distinguishable, but the permuted puzzle distinguishing problem is computationally hard. We provide such constructions in the random oracle model, and in the plain model under the Decisional Diffie-Hellman (DDH) assumption. We additionally observe that the Learning Parity with Noise (LPN) assumption itself can be cast as a permuted puzzle. 3. Partial lower bound for the DE-PIR problem. We make progress towards better understanding the permuted puzzles underlying the DE-PIR constructions, by showing that a toy version of the problem, introduced by Boyle et al. (TCC\u2717), withstands a rich class of attacks, namely those that distinguish solely via statistical queries

    Limits of Preprocessing for Single-Server PIR

    Get PDF
    We present a lower bound for the static cryptographic data structure problem of single-server private information retrieval (PIR). PIR considers the setting where a server holds a database of nn entries and a client wishes to privately retrieve the ii-th entry without revealing the index ii to the server. In our work, we focus on PIR with preprocessing where an rr-bit hint may be computed in a preprocessing stage and stored by the server to be used to perform private queries in expected time tt. We consider the public preprocessing setting of Beimel et al. [JoC, 2004] where the hint is publicly available to everyone including the adversary. We prove that for any single-server computationally secure PIR with preprocessing it must be that tr=Ω(nlogn)tr = \Omega(n \log n) when r=Ω(logn)r = \Omega(\log n). If r=O(logn)r = O(\log n), we show that t=Ω(n)t = \Omega(n). Our lower bound holds even when the scheme errs with probability 1/n21/n^2 and the adversary’s distinguishing advantage is 1/n1/n. Our work improves upon the tr=Ω(n)tr = \Omega(n) lower bound of Beimel et al. [JoC, 2004]. We prove our lower bound in a variant of the cell probe model where only accesses to the memory are charged cost and computation and accesses to the hint are free. Our main technical contribution is a novel use of the cell sampling technique (also known as the incompressibility technique) used to obtain lower bounds on data structures. In previous works, this technique only leveraged the correctness guarantees to prove lower bounds even when used for cryptographic primitives. Our work combines the cell sampling technique with the privacy guarantees of PIR to construct a powerful, polynomial-time adversary that is critical to proving our higher lower bounds
    corecore