5 research outputs found

    Computational Soundness of Uniformity Properties for Multi-party Computation based on LSSS

    Get PDF
    We provide a symbolic model for multi-party computation based on linear secret-sharing scheme, and prove that this model is com- putationally sound: if there is an attack in the computational world, then there is an attack in the symbolic (abstract) model. Our original contri- bution is that we deal with the uniformity properties, which cannot be described using a single execution trace, while considering an unbounded number of sessions of the protocols in the presence of active and adaptive adversaries

    Asymptotically Good Multiplicative LSSS over Galois Rings and Applications to MPC over Z/p^k Z

    Get PDF
    We study information-theoretic multiparty computation (MPC) protocols over rings Z/pkZ\mathbb{Z}/p^k \mathbb{Z} that have good asymptotic communication complexity for a large number of players. An important ingredient for such protocols is arithmetic secret sharing, i.e., linear secret-sharing schemes with multiplicative properties. The standard way to obtain these over fields is with a family of linear codes CC, such that CC, CC^\perp and C2C^2 are asymptotically good (strongly multiplicative). For our purposes here it suffices if the square code C2C^2 is not the whole space, i.e., has codimension at least 1 (multiplicative). Our approach is to lift such a family of codes defined over a finite field F\mathbb F to a Galois ring, which is a local ring that has F\mathbb F as its residue field and that contains Z/pkZ\mathbb{Z}/p^k \mathbb{Z} as a subring, and thus enables arithmetic that is compatible with both structures. Although arbitrary lifts preserve the distance and dual distance of a code, as we demonstrate with a counterexample, the multiplicative property is not preserved. We work around this issue by showing a dedicated lift that preserves \emph{self-orthogonality} (as well as distance and dual distance), for p3p \geq 3. Self-orthogonal codes are multiplicative, therefore we can use existing results of asymptotically good self-dual codes over fields to obtain arithmetic secret sharing over Galois rings. For p=2p = 2 we obtain multiplicativity by using existing techniques of secret-sharing using both CC and CC^\perp, incurring a constant overhead. As a result, we obtain asymptotically good arithmetic secret-sharing schemes over Galois rings. With these schemes in hand, we extend existing field-based MPC protocols to obtain MPC over Z/pkZ\mathbb{Z}/p^k \mathbb{Z}, in the setting of a submaximal adversary corrupting less than a fraction 1/2ε1/2 - \varepsilon of the players, where ε>0\varepsilon > 0 is arbitrarily small. We consider 3 different corruption models. For passive and active security with abort, our protocols communicate O(n)O(n) bits per multiplication. For full security with guaranteed output delivery we use a preprocessing model and get O(n)O(n) bits per multiplication in the online phase and O(nlogn)O(n \log n) bits per multiplication in the offline phase. Thus, we obtain true linear bit complexities, without the common assumption that the ring size depends on the number of players

    Language-Based Techniques for Secure Programming

    Get PDF
    Secure Computation (SC) encompasses many different cryptographic techniques for computing over encrypted data. In particular, Secure Multiparty Computation enables multiple parties to jointly compute a function over their secret inputs. MPC languages offer programmers a familiar environment in which to express their programs, but fall short when confronted with problems that require flexible coordination. More broadly, SC languages do not protect non-expert programmers from violating obliviousness or expected bounds on information leakage. We aim to show that secure programming can be made safer through language-based techniques for expressive, coordinated MPC; probabilistically oblivious execution; and quantitative analysis of information flow. We begin by presenting Symphony, an expressive MPC language that provides flexible coordination of many parties, which has been used to implement the secure shuffle of Laur, Willemson, and Zhang. Next, we present λObliv, a core language guaranteeing that well-typed programs are probabilistically oblivious, which has been used to type check tree-based, nonrecursive ORAM (NORAM). Finally, we present a novel application of dynamic analysis techniques to an existing system for enforcing bounds on information leakage, providing a better balance of precision and performance
    corecore