Inclusion Criteria

Criteria

This project surveys general-purpose compilers for secure multi-party computation. We only include frameworks that meet the following criteria. Questions about these criteria can be raised in the issue tracker.

• Defines a high-level language. This should be human read- and write-able (e.g. not a gate-by-gate circuit representation). This can be an independent domain-specific language, an extension of an existing language, or a library defined within an existing language.
• Processes the language. Frameworks should include some compiler component that converts the language to an intermediate representation (e.g. traditionally this is a circuit, but no particular format is required)
• Executes a protocol. A runtime component should consume the compiler output and execute a protocol. This should be a full execution, including networking, I/O, and other practical concerns.
• Recently maintained. We only include projects that have been updated since 2014.

We will evaluate compiler-only projects on a case-by-case basis. Please create an issue if you maintain such a framework.

Adding your project

If you determine that your project meets the above criteria, you are welcome to nominate it for inclusion by creating a pull request. We request that all PRs include

• a Dockerfile and (optional) install.sh to set up all necessary dependencies, download and install the framework, and compile example programs
• a README.md with the following information: a brief overview of your framework (architecture, protocol type, high-level goals), Docker setup (how to set up and run the docker instance), Architecture (a brief overview of the structure of the framework), Running examples (explicit instructions to generate input, navigate to the appropriate executable files, set up and run an execution), Modifying examples (explicit instructions on how to build examples, including e.g. changes to cmake or make files and compilation steps)
• a source/ directory containing all necessary files to compile and execute three example problems:
  • mult3: multiply three integers together from 3 separate input parties (or secret shared among 2 computational parties), return an integer
  • innerprod: compute the inner product of two length-10 vectors of integers, return an integer
  • xtabs: input is a pair of lists (length 10 or longer). for party A: IDs (integers) and bins (integers [0,5)). for party B: IDs (integers) and values (integers). Computes the bin-wise sum of values for IDs that are in both lists. Return a list (length 5) of sums.

The comments of your pull request should also categorize your framework according to the criteria in the 'basics' table: Protocol family, computation parties supported, whether you support mixed mode computation, whether the protocol is semi-honest or maliciously secure, whether you can defend against a dishonest majority, whether the protocol is information-theoretically secure. If you are not sure, please read the paper for clarification or ask in the PR. Feel free to also help fill in the other tables, in part or full.

Questions about these items should be raised in the issue tracker.

Excuses

There are many valuable projects in the field of MPC that we did not include in our survey. We list some of them here. We determined that these projects do not meet the criteria listed above.

• VIFF (code) 2008, has been "left alive for archival purposes" but they actively recommend against use.
• TASTY (github, paper) has not been updated since 2010.
• PCF (paper, github, paper ii) is a circuit generator. It seems to be subsumed by Frigate. The code was last updated in 2016.
• L1 (paper) 2011, SAP does not release source code, so it's not available to study.
• SEPIA (paper) 2010. This is a special purpose framework for network events.
• EzPC (paper) has not released source code at time of writing.
• FRESCO (github) This is an API for secure computation. It aims to make frameworks more consistent but doesn't provide an end-to-end framework itself.
• SCAPI (github) is an API for primitives, protocols, and communication channels commonly used in MPC.
• dualBatchEx (github, paper). The primary contribution is a protocol implementation. It consumes circuits.
• Duplo (github) This is primarily a protocol implementation. It uses Frigate as a front-end, which we discuss.
• TinyLego (github) is primarily a protocol implementation. The front-end is a circuit implementation & parser.
• JustGarble (website). This library only implements garbling and evaluation on Boolean circuits. It doesn't include communication or circuit generation. It's mostly subsumed by TinyGarble.
• Semi-honest BMR (github). This is primarily a protocol implementation. It consumes circuits.
• SPDZ has been subsumed by SCALE-MAMBA. We had already reviewed SPDZ when S-M was released, so we include a SPDZ Docker instance and sample programs here for posterity.