Welcome to MP-SPDZ’s documentation!

MP-SPDZ is a framework for multi-party computation, a privacy-enhancing technology focused on input privacy. It uses protocols running between several entities to create a conceptual black box in which data can operated on privately. Such a black box could be created between banks or healthcare providers to jointly operate on privacy-sensitive data. Please see this gentle introduction for more information on multi-party computation.

If you’re new to MP-SPDZ, consider the following:

1. Quickstart tutorial

2. Machine learning quickstart

3. Implemented protocols

4. Troubleshooting

5. Input/Output lists all the ways of getting data in and out.

Contents:

• Getting Started
  • Frequently Asked Questions
  • Contact
    • Filing Issues
  • Paper and Citation
  • TL;DR (Binary Distribution on Linux or Source Distribution on macOS)
  • TL;DR (Source from GitHub)
  • TL;DR (Docker)
  • Relevant papers
  • Preface
  • Protocols
    • Finding the most efficient protocol
  • History
  • Overview
  • Requirements
  • Compilation
• Running Computation
  • Compiling high-level programs
    • Arithmetic modulo a prime
    • Arithmetic modulo 2^k
    • Binary circuits
    • Mixed circuits
      • Classic daBits
      • Extended daBits
      • Local share conversion
      • Finding the most efficient variant
      • Manual conversion
    • Bristol Fashion circuits
    • Compiling programs directly in Python
    • Compiling and running programs from external directories
  • TensorFlow inference
  • Emulation
  • Dishonest majority
    • Secret sharing
    • Yao’s garbled circuits
  • Honest majority
    • Protocols with function-dependent preprocessing
  • Dealer model
  • BMR
  • Online-only benchmarking
    • SPDZ
      • To setup for benchmarking the online phase
      • To compile a program
      • To run a program
    • SPDZ2k
    • Other protocols
    • BMR
      • Oblivious RAM
  • Preprocessing as required
  • Benchmarking offline phases
    • Benchmarking the MASCOT or SPDZ2k offline phase
    • Benchmarking Overdrive offline phases
      • Memory usage
• Compilation Process
  • Direct Compilation in Python
  • Compilation vs run time
• Run-Time Options
  • Efficiency trade-offs
  • Protocol options
  • Network setup
  • Local facilities
• High-Level Interface
  • Compiler.types module
    • Basic types
    • Container types
  • Compiler.GC.types module
  • Compiler.library module
  • Compiler.mpc_math module
  • Compiler.ml module
  • Compiler.decision_tree module
  • Compiler.circuit module
  • Compiler.program module
  • Compiler.oram module
  • Compiler.sqrt_oram module
  • Compiler.path_oblivious_heap module
  • Compiler.dijkstra module
  • Compiler.sorting module
• Bytecode Utilities
  • Memory usage
  • Preprocessing usage
  • Human-readable bytecode/circuit representation
• The Journey of a Program
  • Execution
• Compiler Optimizations
  • Merging
  • CISC
• Virtual Machine
  • Schedule File
  • Bytecode
    • Memory size indication
  • Instructions
  • Compiler.instructions module
  • Compiler.GC.instructions module
• Low-Level Interface
  • Thread Safety
  • Domain Types
  • Share Types
  • Protocol Setup
  • Protocol Interfaces
  • Domain Reference
• Using High-Level Functionality in C++
  • Vector arguments and return values
  • Binary values
  • C++ compilation
  • Reference
• Navigating the C++ Code
  • Mathematical Domains
  • Communication
  • Randomness
  • Protocols
  • Virtual Machines
• Machine Learning Quickstart
• Machine Learning
  • Data Input
    • Integrated Data Input
      • Data preprocessing
    • Independent Data Input
  • Training
    • Logistic regression with SGD
    • Linear regression with SGD
    • PyTorch interface
    • Keras interface
    • Decision trees
      • Data preparation
  • Loading pre-trained models
  • Storing and loading models
  • Exporting models
• Networking
  • Internal Infrastructure
    • Reference
• Input/Output
  • Private Inputs from Computing Parties
  • Compile-Time Data via Private Input
  • Public Inputs
  • Public Outputs
  • Private Outputs to Computing Parties
  • Binary Output
  • Clients (Non-computing Parties)
  • Secret Shares via Socket
  • Secret Shares via Files
  • Python Trusted Client Tutorial
  • Python Reference
  • C++ Reference
• Client Interface
  • Working Examples
  • I/O MPC Instructions
    • Connection Setup
    • Data Exchange
  • Client-Side Interface
• Multinode Computation Example
• Non-linear Computation
  • Mixed-Circuit Computation
    • Protocol Pairs
• Preprocessing
  • Separate preprocessing
• Lowest-Level Interface
• Adding a Protocol
  • Reference
• Adding an Instruction
  • Frontend
  • Backend
    • Parsing
    • Resourcing
    • Execution
• Homomorphic Encryption
  • Reference
• Threshold ECDSA
  • Compilation
  • Running
• Troubleshooting
  • Crash without error message, Killed, or bad_alloc
  • List indices must be integers or slices
  • Local variable referenced before assignment
  • compile.py takes too long or runs out of memory
  • Cannot derive truth value from register
  • Incorrect results when using sfix
  • Variable results when using sfix
  • Only party 0 produces outputs
  • Order of memory instructions not preserved
  • High number of rounds or slow WAN execution
  • Odd timings
  • Disparities in round figures
  • Handshake failures
  • Connection failures
  • Internally called tape has unknown offline data usage
  • Illegal instruction
  • Invalid instruction
  • Computation used more preprocessing than expected
  • Required prime bit length is not the same as -F parameter during compilation
  • Prime number not compatible with encryption scheme
  • Windows/VirtualBox performance
  • mac_fail
  • Debugging errors in a virtual machine

Indices and tables

• Index

• Module Index

• Search Page