50 research outputs found
Fourier-based Function Secret Sharing with General Access Structure
Function secret sharing (FSS) scheme is a mechanism that calculates a
function f(x) for x in {0,1}^n which is shared among p parties, by using
distributed functions f_i:{0,1}^n -> G, where G is an Abelian group, while the
function f:{0,1}^n -> G is kept secret to the parties. Ohsawa et al. in 2017
observed that any function f can be described as a linear combination of the
basis functions by regarding the function space as a vector space of dimension
2^n and gave new FSS schemes based on the Fourier basis. All existing FSS
schemes are of (p,p)-threshold type. That is, to compute f(x), we have to
collect f_i(x) for all the distributed functions. In this paper, as in the
secret sharing schemes, we consider FSS schemes with any general access
structure. To do this, we observe that Fourier-based FSS schemes by Ohsawa et
al. are compatible with linear secret sharing scheme. By incorporating the
techniques of linear secret sharing with any general access structure into the
Fourier-based FSS schemes, we show Fourier-based FSS schemes with any general
access structure.Comment: 12 page
Foundations of Homomorphic Secret Sharing
Homomorphic secret sharing (HSS) is the secret sharing analogue of homomorphic encryption. An HSS scheme supports a local evaluation of functions on shares of one or more secret inputs, such that the resulting shares of the output are short. Some applications require the stronger notion of additive HSS, where the shares of the output add up to the output over some finite Abelian group. While some strong positive results for HSS are known under specific cryptographic assumptions, many natural questions remain open.
We initiate a systematic study of HSS, making the following contributions.
- A definitional framework. We present a general framework for defining HSS schemes that unifies and extends several previous notions from the literature, and cast known results within this framework.
- Limitations. We establish limitations on information-theoretic multi-input HSS with short output shares via a relation with communication complexity. We also show that additive HSS for non-trivial functions, even the AND of two input bits, implies non-interactive key exchange, and is therefore unlikely to be implied by public-key encryption or even oblivious transfer.
- Applications. We present two types of applications of HSS. First, we construct 2-round protocols for secure multiparty computation from a simple constant-size instance of HSS. As a corollary, we obtain 2-round protocols with attractive asymptotic efficiency features under the Decision Diffie Hellman (DDH) assumption. Second, we use HSS to obtain nearly optimal worst-case to average-case reductions in P. This in turn has applications to fine-grained average-case hardness and verifiable computation
Function Secret Sharing: Improvements and Extensions
Function Secret Sharing (FSS), introduced by Boyle et al. (Eurocrypt 2015), provides a way for additively secret-sharing a function from a given function family . More concretely, an -party FSS scheme splits a function , for some abelian group , into functions , described by keys , such that and every strict subset of the keys hides . A Distributed Point Function (DPF) is a special case where is the family of point functions, namely functions that evaluate to on the input and to 0 on all other inputs.
FSS schemes are useful for applications that involve privately reading from or writing to distributed databases while minimizing the amount of communication. These include different flavors of private information retrieval (PIR), as well as a recent application of DPF for large-scale anonymous messaging.
We improve and extend previous results in several ways:
- Simplified FSS constructions. We introduce a tensoring operation for FSS which is used to obtain a conceptually simpler derivation of previous constructions and present our new constructions.
- Improved 2-party DPF. We reduce the key size of the PRG-based DPF scheme of Boyle et al. roughly by a factor of 4 and optimize its computational cost. The optimized DPF significantly improves the concrete costs of 2-server PIR and related primitives.
- FSS for new function families. We present an efficient PRG-based 2-party FSS scheme for the family of decision trees, leaking only the topology of the tree and the internal node labels. We apply this towards FSS for multi-dimensional intervals. We also present a general technique for obtaining more expressive FSS schemes by increasing the number of parties.
- Verifiable FSS. We present efficient protocols for verifying that keys , obtained from a potentially malicious user, are consistent with some . Such a verification may be critical for applications that involve private writing or voting by many users
Group-Based Secure Computation: Optimizing Rounds, Communication, and Computation
A recent work of Boyle et al. (Crypto 2016) suggests that ``group-based\u27\u27 cryptographic protocols, namely ones that only rely on a cryptographically hard (Abelian) group, can be surprisingly powerful. In particular, they present succinct two-party protocols for securely computing branching programs and NC1 circuits under the DDH assumption, providing the first alternative to fully homomorphic encryption.
In this work we further explore the power of group-based secure computation protocols, improving both their asymptotic and concrete efficiency. We obtain the following results.
- Black-box use of group. We modify the succinct protocols of Boyle et al. so that they only make a black-box use of the underlying group, eliminating an expensive non-black-box setup phase.
- Round complexity. For any constant number of parties, we obtain 2-round MPC protocols based on a PKI setup under the DDH assumption. Prior to our work, such protocols were only known using fully homomorphic encryption or indistinguishability obfuscation.
- Communication complexity. Under DDH, we present a secure 2-party protocol for any NC1 or log-space computation with n input bits and m output bits using n+(1+o(1)) m+\poly(\lambda) bits of communication, where \lambda is a security parameter. In particular, our protocol can generate n instances of bit-oblivious-transfer using (4+o(1))\cdot n bits of communication. This gives the first constant-rate OT protocol under DDH.
- Computation complexity. We present several techniques for improving the computational cost of the share conversion procedure of Boyle et al., improving the concrete efficiency of group-based protocols by several orders of magnitude
Breaking the Circuit Size Barrier for Secure Computation Under DDH
Under the Decisional Diffie-Hellman (DDH) assumption, we present a 2-out-of-2 secret sharing scheme that supports a compact evaluation of branching programs on the shares. More concretely, there is an evaluation algorithm \Eval with a single bit of output, such that if an input is shared into , then for any deterministic branching program of size we have that \Eval(P,w^0)\oplus \Eval(P,w^1)=P(w) except with at most failure probability. The running time of the sharing algorithm is polynomial in and the security parameter , and that of \Eval is polynomial in , and . This applies as a special case to boolean formulas of size or boolean circuits of depth . We also present a public-key variant that enables homomorphic computation on inputs contributed by multiple clients.
The above result implies the following DDH-based applications:
- A secure 2-party computation protocol for evaluating any branching program of size , where the communication complexity is linear in the input size and only the running time grows with .
- A secure 2-party computation protocol for evaluating any layered boolean circuit of size and outputs with communication complexity O(S/\log S)+m\cdot\poly(\lambda).
-A 2-party {\em function secret sharing} scheme, as defined by Boyle et al. (Eurocrypt 2015), for general branching programs (with inverse polynomial error probability).
- A 1-round 2-server {\em private information retrieval} scheme supporting general searches expressed by branching programs
Accumulating Automata and Cascaded Equations Automata for Communicationless Information Theoretically Secure Multi-Party Computation
Information theoretically secure multi-party computation implies severe communication overhead among the computing participants, as there is a need to reduce the polynomial degree after each multiplication. In particular, when the input is (practically) unbounded, the number of multiplications and therefore the communication bandwidth among the participants may be practically unbounded. In some scenarios the communication among the participants should better be avoided altogether, avoiding linkage among the secret share holders. For example, when processes in clouds operate over streaming secret shares without communicating with each other, they can actually hide their linkage and activity in the crowd. An adversary that is able to compromise processes in the cloud may need to capture and analyze a very large number of possible shares.
Consider a dealer that wants to repeatedly compute functions on a long file with the assistance of servers. The dealer does not wish to leak either the input file or the result of the computation to any of the servers. We investigate this setting given two constraints. The dealer is allowed to share each symbol of the input file among the servers and is allowed to halt the computation at any point. However, the dealer is otherwise stateless. Furthermore, each server is not allowed any communication beyond the shares of the inputs that it receives and the information it provides to the dealer during reconstruction.
We present a protocol in this setting for generalized string matching, including wildcards. We also present solutions for identifying other regular languages, as well as particular context free and context sensitive languages. The results can be described by a newly defined {\em accumulating automata} and {\em cascaded equations automata} which may be of an independent interest. As an application of {\em accumulating automata} and {\em cascaded equations automata}, secure and private repeated computations on a secret shared file among communicationless clouds are presented
Lightweight Techniques for Private Heavy Hitters
This paper presents a new protocol for solving the private heavy-hitters
problem. In this problem, there are many clients and a small set of
data-collection servers. Each client holds a private bitstring. The servers
want to recover the set of all popular strings, without learning anything else
about any client's string. A web-browser vendor, for instance, can use our
protocol to figure out which homepages are popular, without learning any user's
homepage. We also consider the simpler private subset-histogram problem, in
which the servers want to count how many clients hold strings in a particular
set without revealing this set to the clients.
Our protocols use two data-collection servers and, in a protocol run, each
client send sends only a single message to the servers. Our protocols protect
client privacy against arbitrary misbehavior by one of the servers and our
approach requires no public-key cryptography (except for secure channels), nor
general-purpose multiparty computation. Instead, we rely on incremental
distributed point functions, a new cryptographic tool that allows a client to
succinctly secret-share the labels on the nodes of an exponentially large
binary tree, provided that the tree has a single non-zero path. Along the way,
we develop new general tools for providing malicious security in applications
of distributed point functions.
In an experimental evaluation with two servers on opposite sides of the U.S.,
the servers can find the 200 most popular strings among a set of 400,000
client-held 256-bit strings in 54 minutes. Our protocols are highly
parallelizable. We estimate that with 20 physical machines per logical server,
our protocols could compute heavy hitters over ten million clients in just over
one hour of computation.Comment: To appear in IEEE Security & Privacy 202
Locality-Preserving Hashing for Shifts with Connections to Cryptography
Can we sense our location in an unfamiliar environment by taking a
sublinear-size sample of our surroundings? Can we efficiently encrypt a message
that only someone physically close to us can decrypt? To solve this kind of
problems, we introduce and study a new type of hash functions for finding
shifts in sublinear time. A function is a
{\em locality-preserving hash function for shifts} (LPHS) if: (1)
can be computed by (adaptively) querying bits of its input, and (2)
, where is random and
denotes a cyclic shift by one bit to the left. We make the following
contributions.
* Near-optimal LPHS via Distributed Discrete Log: We establish a general
two-way connection between LPHS and algorithms for distributed discrete
logarithm in the generic group model. Using such an algorithm of Dinur et al.
(Crypto 2018), we get LPHS with near-optimal error of .
This gives an unusual example for the usefulness of group-based cryptography in
a post-quantum world. We extend the positive result to non-cyclic and
worst-case variants of LPHS.
* Multidimensional LPHS: We obtain positive and negative results for a
multidimensional extension of LPHS, making progress towards an optimal
2-dimensional LPHS.
* Applications: We demonstrate the usefulness of LPHS by presenting
cryptographic and algorithmic applications. In particular, we apply
multidimensional LPHS to obtain an efficient "packed" implementation of
homomorphic secret sharing and a sublinear-time implementation of
location-sensitive encryption whose decryption requires a significantly
overlapping view
Sublinear GMW-Style Compiler for MPC with Preprocessing
We consider the efficiency of protocols for secure multiparty computation (MPC) with a dishonest majority. A popular approach for the design of such protocols is to employ preprocessing. Before the inputs are known, the parties generate correlated secret randomness, which is consumed by a fast and possibly ``information-theoretic\u27\u27 online protocol.
A powerful technique for securing such protocols against malicious parties uses homomorphic MACs to authenticate the values produced by the online protocol. Compared to a baseline protocol, which is only secure against semi-honest parties, this involves a significant increase in the size of the correlated randomness, by a factor of up to a statistical security parameter. Different approaches for partially mitigating this extra storage cost come at the expense of increasing the online communication.
In this work we propose a new technique for protecting MPC with preprocessing against malicious parties. We show that for circuit evaluation protocols that satisfy mild security and structural requirements, that are met by many standard protocols with semi-honest security, the extra additive storage and online communication costs are both logarithmic in the circuit size. This applies to Boolean circuits and to arithmetic circuits over fields or rings, and to both information-theoretic and computationally secure protocols. Our protocol can be viewed as a sublinear information-theoretic variant of the celebrated ``GMW compiler\u27\u27 that applies to natural protocols for MPC with preprocessing.
Our compiler makes a novel use of the techniques of Boneh et al. (Crypto 2019) for sublinear distributed zero knowledge, which were previously only used in the setting of honest-majority MPC