3,175 research outputs found
Language-based Techniques for Practical and Trustworthy Secure Multi-party Computations
Secure Multi-party Computation (MPC) enables a set of parties to
collaboratively compute, using cryptographic protocols, a function
over their private data in a way that the participants do not see
each other's data, they only see the final output. Typical MPC
examples include statistical computations over joint private data,
private set intersection, and auctions. While these applications are
examples of monolithic MPC, richer MPC
applications move between "normal" (i.e., per-party local)
and "secure" (i.e., joint, multi-party secure) modes
repeatedly, resulting overall in mixed-mode computations. For
example, we might use MPC to implement the role of the dealer in a
game of mental poker -- the game will be divided into rounds of
local decision-making (e.g. bidding) and joint interaction
(e.g. dealing). Mixed-mode computations are also used to improve
performance over monolithic secure computations.
Starting with the Fairplay project, several MPC frameworks have been
proposed in the last decade to help programmers write MPC applications in
a high-level language, while the toolchain manages the
low-level details. However, these frameworks are either not expressive
enough to allow writing mixed-mode applications or lack formal
specification, and reasoning capabilities, thereby diminishing the
parties' trust in such tools, and the programs written using
them. Furthermore, none of the frameworks provides a verified
toolchain to run the MPC programs, leaving the potential of security holes
that can compromise the privacy of parties' data.
This dissertation presents language-based techniques to make MPC more
practical and trustworthy. First, it presents the design and
implementation of a new MPC Domain Specific Language, called Wysteria,
for writing rich mixed-mode MPC applications. Wysteria provides several
benefits over previous languages, including a conceptual single thread of
control, generic support for more than two parties, high-level abstractions
for secret shares, and a fully formalized type system and operational
semantics. Using Wysteria, we have implemented several MPC applications,
including, for the first time, a card dealing application.
The dissertation next
presents Wys*, an embedding of Wysteria in F*, a
full-featured verification oriented programming language. Wys*
improves on Wysteria along three lines: (a) It enables programmers to
formally verify the correctness and security properties of their
programs. As far as we know, Wys* is the first language to
provide verification capabilities for MPC programs. (b) It provides a
partially verified toolchain to run MPC programs, and finally (c) It
enables the MPC programs to use, with no extra effort, standard
language constructs from the host language F*, thereby making it
more usable and scalable.
Finally, the dissertation develops static analyses that help optimize
monolithic MPC programs into mixed-mode MPC programs, while providing
similar privacy guarantees as the monolithic versions
Combining behavioural types with security analysis
Today's software systems are highly distributed and interconnected, and they
increasingly rely on communication to achieve their goals; due to their
societal importance, security and trustworthiness are crucial aspects for the
correctness of these systems. Behavioural types, which extend data types by
describing also the structured behaviour of programs, are a widely studied
approach to the enforcement of correctness properties in communicating systems.
This paper offers a unified overview of proposals based on behavioural types
which are aimed at the analysis of security properties
Prochlo: Strong Privacy for Analytics in the Crowd
The large-scale monitoring of computer users' software activities has become
commonplace, e.g., for application telemetry, error reporting, or demographic
profiling. This paper describes a principled systems architecture---Encode,
Shuffle, Analyze (ESA)---for performing such monitoring with high utility while
also protecting user privacy. The ESA design, and its Prochlo implementation,
are informed by our practical experiences with an existing, large deployment of
privacy-preserving software monitoring.
(cont.; see the paper
ARPA Whitepaper
We propose a secure computation solution for blockchain networks. The
correctness of computation is verifiable even under malicious majority
condition using information-theoretic Message Authentication Code (MAC), and
the privacy is preserved using Secret-Sharing. With state-of-the-art multiparty
computation protocol and a layer2 solution, our privacy-preserving computation
guarantees data security on blockchain, cryptographically, while reducing the
heavy-lifting computation job to a few nodes. This breakthrough has several
implications on the future of decentralized networks. First, secure computation
can be used to support Private Smart Contracts, where consensus is reached
without exposing the information in the public contract. Second, it enables
data to be shared and used in trustless network, without disclosing the raw
data during data-at-use, where data ownership and data usage is safely
separated. Last but not least, computation and verification processes are
separated, which can be perceived as computational sharding, this effectively
makes the transaction processing speed linear to the number of participating
nodes. Our objective is to deploy our secure computation network as an layer2
solution to any blockchain system. Smart Contracts\cite{smartcontract} will be
used as bridge to link the blockchain and computation networks. Additionally,
they will be used as verifier to ensure that outsourced computation is
completed correctly. In order to achieve this, we first develop a general MPC
network with advanced features, such as: 1) Secure Computation, 2) Off-chain
Computation, 3) Verifiable Computation, and 4)Support dApps' needs like
privacy-preserving data exchange
Cryptographically Secure Information Flow Control on Key-Value Stores
We present Clio, an information flow control (IFC) system that transparently
incorporates cryptography to enforce confidentiality and integrity policies on
untrusted storage. Clio insulates developers from explicitly manipulating keys
and cryptographic primitives by leveraging the policy language of the IFC
system to automatically use the appropriate keys and correct cryptographic
operations. We prove that Clio is secure with a novel proof technique that is
based on a proof style from cryptography together with standard programming
languages results. We present a prototype Clio implementation and a case study
that demonstrates Clio's practicality.Comment: Full version of conference paper appearing in CCS 201
- …