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
• Recommended Reading
• Compilation Process
  • Compiler options
  • 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
    • Array
      • Array.assign()
      • Array.assign_all()
      • Array.assign_part_vector()
      • Array.assign_vector()
      • Array.binary_output()
      • Array.concat()
      • Array.create_from()
      • Array.dot()
      • Array.expand_to_vector()
      • Array.get()
      • Array.get_part()
      • Array.get_part_vector()
      • Array.get_reverse_vector()
      • Array.get_vector()
      • Array.input_from()
      • Array.maybe_get()
      • Array.maybe_set()
      • Array.permute()
      • Array.print_reveal_nested()
      • Array.randomize()
      • Array.read_from_file()
      • Array.read_from_socket()
      • Array.reveal()
      • Array.reveal_list()
      • Array.reveal_nested()
      • Array.reveal_to()
      • Array.reveal_to_binary_output()
      • Array.reveal_to_clients()
      • Array.reveal_to_socket_by_party()
      • Array.same_shape()
      • Array.secure_permute()
      • Array.secure_shuffle()
      • Array.shuffle()
      • Array.sort()
      • Array.sum()
      • Array.to_column_matrix()
      • Array.to_row_matrix()
      • Array.write_to_file()
      • Array.write_to_socket()
    • Matrix
      • Matrix.assign()
      • Matrix.assign_all()
      • Matrix.assign_part_vector()
      • Matrix.assign_vector()
      • Matrix.assign_vector_by_indices()
      • Matrix.concat()
      • Matrix.concat_columns()
      • Matrix.diag()
      • Matrix.direct_mul()
      • Matrix.direct_mul_trans()
      • Matrix.direct_trans_mul()
      • Matrix.dot()
      • Matrix.get_column()
      • Matrix.get_part()
      • Matrix.get_part_vector()
      • Matrix.get_slice_vector()
      • Matrix.get_vector()
      • Matrix.get_vector_by_indices()
      • Matrix.iadd()
      • Matrix.input_from()
      • Matrix.mul_trans()
      • Matrix.mul_trans_to()
      • Matrix.permute()
      • Matrix.print_reveal_nested()
      • Matrix.randomize()
      • Matrix.read_from_file()
      • Matrix.read_from_socket()
      • Matrix.reveal()
      • Matrix.reveal_list()
      • Matrix.reveal_nested()
      • Matrix.reveal_to_binary_output()
      • Matrix.reveal_to_clients()
      • Matrix.reveal_to_socket_by_party()
      • Matrix.same_shape()
      • Matrix.schur()
      • Matrix.secure_permute()
      • Matrix.secure_shuffle()
      • Matrix.set_column()
      • Matrix.sort()
      • Matrix.trace()
      • Matrix.trans_mul()
      • Matrix.trans_mul_to()
      • Matrix.transpose()
      • Matrix.write_to_file()
      • Matrix.write_to_socket()
    • MemValue
      • MemValue.iadd()
      • MemValue.max()
      • MemValue.min()
      • MemValue.read()
      • MemValue.reveal()
      • MemValue.reveal_to_clients()
      • MemValue.reveal_to_socket_by_party()
      • MemValue.square()
      • MemValue.write()
    • MultiArray
      • MultiArray.assign()
      • MultiArray.assign_all()
      • MultiArray.assign_part_vector()
      • MultiArray.assign_vector()
      • MultiArray.assign_vector_by_indices()
      • MultiArray.concat()
      • MultiArray.diag()
      • MultiArray.direct_mul()
      • MultiArray.direct_mul_trans()
      • MultiArray.direct_trans_mul()
      • MultiArray.dot()
      • MultiArray.get_column()
      • MultiArray.get_part()
      • MultiArray.get_part_vector()
      • MultiArray.get_slice_vector()
      • MultiArray.get_vector()
      • MultiArray.get_vector_by_indices()
      • MultiArray.iadd()
      • MultiArray.input_from()
      • MultiArray.mul_trans()
      • MultiArray.mul_trans_to()
      • MultiArray.permute()
      • MultiArray.print_reveal_nested()
      • MultiArray.randomize()
      • MultiArray.read_from_file()
      • MultiArray.read_from_socket()
      • MultiArray.reveal()
      • MultiArray.reveal_list()
      • MultiArray.reveal_nested()
      • MultiArray.reveal_to_binary_output()
      • MultiArray.reveal_to_clients()
      • MultiArray.reveal_to_socket_by_party()
      • MultiArray.same_shape()
      • MultiArray.schur()
      • MultiArray.secure_permute()
      • MultiArray.secure_shuffle()
      • MultiArray.set_column()
      • MultiArray.sort()
      • MultiArray.trace()
      • MultiArray.trans_mul()
      • MultiArray.trans_mul_to()
      • MultiArray.transpose()
      • MultiArray.write_to_file()
      • MultiArray.write_to_socket()
    • cfix
      • cfix.Array()
      • cfix.Matrix()
      • cfix.MemValue()
      • cfix.Tensor()
      • cfix.binary_output()
      • cfix.iadd()
      • cfix.less_than()
      • cfix.load_mem()
      • cfix.max()
      • cfix.min()
      • cfix.print_plain()
      • cfix.read_from_socket()
      • cfix.set_precision()
      • cfix.square()
      • cfix.store_in_mem()
      • cfix.write_to_socket()
    • cfloat
      • cfloat.binary_output()
      • cfloat.print_float_plain()
    • cgf2n
      • cgf2n.Array()
      • cgf2n.Matrix()
      • cgf2n.MemValue()
      • cgf2n.Tensor()
      • cgf2n.binary_output()
      • cgf2n.bit_and()
      • cgf2n.bit_compose()
      • cgf2n.bit_decompose()
      • cgf2n.bit_not()
      • cgf2n.bit_or()
      • cgf2n.bit_xor()
      • cgf2n.cond_swap()
      • cgf2n.field_div()
      • cgf2n.half_adder()
      • cgf2n.iadd()
      • cgf2n.if_else()
      • cgf2n.load_mem()
      • cgf2n.malloc()
      • cgf2n.max()
      • cgf2n.min()
      • cgf2n.print_reg_plain()
      • cgf2n.read_from_file()
      • cgf2n.reveal()
      • cgf2n.square()
      • cgf2n.store_in_mem()
      • cgf2n.update()
      • cgf2n.write_to_file()
      • cgf2n.write_to_socket()
    • cint
      • cint.Array()
      • cint.Matrix()
      • cint.MemValue()
      • cint.Tensor()
      • cint.binary_output()
      • cint.bit_adder()
      • cint.bit_and()
      • cint.bit_compose()
      • cint.bit_decompose()
      • cint.bit_not()
      • cint.bit_or()
      • cint.bit_xor()
      • cint.cond_swap()
      • cint.digest()
      • cint.field_div()
      • cint.half_adder()
      • cint.iadd()
      • cint.if_else()
      • cint.legendre()
      • cint.less_than()
      • cint.load_mem()
      • cint.malloc()
      • cint.max()
      • cint.min()
      • cint.mod2m()
      • cint.print_if()
      • cint.print_reg_plain()
      • cint.read_from_file()
      • cint.read_from_socket()
      • cint.reveal()
      • cint.right_shift()
      • cint.square()
      • cint.store_in_mem()
      • cint.to_regint()
      • cint.update()
      • cint.write_to_file()
      • cint.write_to_socket()
    • localint
      • localint.output()
    • personal
      • personal.binary_output()
      • personal.bit_decompose()
      • personal.read_fix()
      • personal.read_int()
      • personal.reveal_to()
    • regint
      • regint.Array()
      • regint.Matrix()
      • regint.MemValue()
      • regint.Tensor()
      • regint.binary_output()
      • regint.bit_adder()
      • regint.bit_and()
      • regint.bit_compose()
      • regint.bit_decompose()
      • regint.bit_not()
      • regint.bit_or()
      • regint.bit_xor()
      • regint.cond_swap()
      • regint.get_random()
      • regint.half_adder()
      • regint.iadd()
      • regint.if_else()
      • regint.inc()
      • regint.load_mem()
      • regint.malloc()
      • regint.max()
      • regint.min()
      • regint.mod2m()
      • regint.pop()
      • regint.print_if()
      • regint.print_reg_plain()
      • regint.push()
      • regint.read_from_file()
      • regint.read_from_socket()
      • regint.reveal()
      • regint.shuffle()
      • regint.square()
      • regint.store_in_mem()
      • regint.update()
      • regint.write_to_file()
      • regint.write_to_socket()
    • sfix
      • sfix.Array()
      • sfix.Matrix()
      • sfix.MemValue()
      • sfix.Tensor()
      • sfix.bit_decompose()
      • sfix.compute_reciprocal()
      • sfix.dot()
      • sfix.dot_product()
      • sfix.equal()
      • sfix.get_input_from()
      • sfix.get_random()
      • sfix.greater_equal()
      • sfix.greater_than()
      • sfix.iadd()
      • sfix.input_tensor_from()
      • sfix.input_tensor_from_client()
      • sfix.input_tensor_via()
      • sfix.less_equal()
      • sfix.less_than()
      • sfix.load_mem()
      • sfix.max()
      • sfix.min()
      • sfix.not_equal()
      • sfix.read_from_file()
      • sfix.receive_from_client()
      • sfix.rep_type
      • sfix.reveal()
      • sfix.reveal_to()
      • sfix.reveal_to_clients()
      • sfix.round_nearest
      • sfix.set_precision()
      • sfix.square()
      • sfix.store_in_mem()
      • sfix.update()
      • sfix.write_shares_to_socket()
      • sfix.write_to_file()
    • sfloat
      • sfloat.Array()
      • sfloat.Matrix()
      • sfloat.MemValue()
      • sfloat.Tensor()
      • sfloat.get_input_from()
      • sfloat.iadd()
      • sfloat.input_tensor_from()
      • sfloat.input_tensor_from_client()
      • sfloat.input_tensor_via()
      • sfloat.load_mem()
      • sfloat.max()
      • sfloat.min()
      • sfloat.reveal()
      • sfloat.round_to_int()
      • sfloat.square()
      • sfloat.store_in_mem()
      • sfloat.update()
    • sgf2n
      • sgf2n.Array()
      • sgf2n.Matrix()
      • sgf2n.MemValue()
      • sgf2n.Tensor()
      • sgf2n.bit_and()
      • sgf2n.bit_compose()
      • sgf2n.bit_decompose()
      • sgf2n.bit_not()
      • sgf2n.bit_or()
      • sgf2n.bit_xor()
      • sgf2n.cond_swap()
      • sgf2n.dot_product()
      • sgf2n.equal()
      • sgf2n.field_div()
      • sgf2n.get_input_from()
      • sgf2n.get_random_bit()
      • sgf2n.get_random_input_mask_for()
      • sgf2n.get_random_inverse()
      • sgf2n.get_random_square()
      • sgf2n.get_random_triple()
      • sgf2n.half_adder()
      • sgf2n.iadd()
      • sgf2n.if_else()
      • sgf2n.input_tensor_from()
      • sgf2n.input_tensor_from_client()
      • sgf2n.input_tensor_via()
      • sgf2n.load_mem()
      • sgf2n.malloc()
      • sgf2n.max()
      • sgf2n.min()
      • sgf2n.not_equal()
      • sgf2n.raw_right_shift()
      • sgf2n.read_from_file()
      • sgf2n.reveal()
      • sgf2n.reveal_to()
      • sgf2n.right_shift()
      • sgf2n.square()
      • sgf2n.store_in_mem()
      • sgf2n.update()
      • sgf2n.write_to_file()
    • sint
      • sint.Array()
      • sint.Matrix()
      • sint.MemValue()
      • sint.Tensor()
      • sint.bit_adder()
      • sint.bit_and()
      • sint.bit_compose()
      • sint.bit_decompose()
      • sint.bit_not()
      • sint.bit_or()
      • sint.bit_xor()
      • sint.cond_swap()
      • sint.dot_product()
      • sint.equal()
      • sint.field_div()
      • sint.get_dabit()
      • sint.get_edabit()
      • sint.get_input_from()
      • sint.get_random()
      • sint.get_random_bit()
      • sint.get_random_input_mask_for()
      • sint.get_random_int()
      • sint.get_random_inverse()
      • sint.get_random_square()
      • sint.get_random_triple()
      • sint.greater_equal()
      • sint.greater_than()
      • sint.half_adder()
      • sint.iadd()
      • sint.if_else()
      • sint.input_tensor_from()
      • sint.input_tensor_from_client()
      • sint.input_tensor_via()
      • sint.int_div()
      • sint.int_mod()
      • sint.left_shift()
      • sint.less_equal()
      • sint.less_than()
      • sint.load_mem()
      • sint.malloc()
      • sint.max()
      • sint.min()
      • sint.mod2m()
      • sint.not_equal()
      • sint.pow2()
      • sint.prefix_sum()
      • sint.private_division()
      • sint.raw_right_shift()
      • sint.read_from_file()
      • sint.read_from_socket()
      • sint.receive_from_client()
      • sint.reveal()
      • sint.reveal_to()
      • sint.reveal_to_clients()
      • sint.right_shift()
      • sint.round()
      • sint.square()
      • sint.store_in_mem()
      • sint.update()
      • sint.write_fully_to_socket()
      • sint.write_shares_to_socket()
      • sint.write_to_file()
      • sint.write_to_socket()
    • sintbit
  • Compiler.GC.types module
    • cbits
      • cbits.Array()
      • cbits.MemValue()
      • cbits.bit_and()
      • cbits.bit_not()
      • cbits.bit_or()
      • cbits.bit_xor()
      • cbits.get_type()
      • cbits.half_adder()
      • cbits.if_else()
      • cbits.update()
    • sbit
      • sbit.Array()
      • sbit.MemValue()
      • sbit.bit_adder()
      • sbit.bit_and()
      • sbit.bit_not()
      • sbit.bit_or()
      • sbit.bit_xor()
      • sbit.get_input_from()
      • sbit.get_type()
      • sbit.half_adder()
      • sbit.if_else()
      • sbit.popcnt()
      • sbit.update()
    • sbitfixvec
      • sbitfixvec.Array()
      • sbitfixvec.MemValue()
      • sbitfixvec.add()
      • sbitfixvec.bit_decompose()
      • sbitfixvec.compute_reciprocal()
      • sbitfixvec.equal()
      • sbitfixvec.get_input_from()
      • sbitfixvec.get_random()
      • sbitfixvec.greater_equal()
      • sbitfixvec.greater_than()
      • sbitfixvec.iadd()
      • sbitfixvec.less_equal()
      • sbitfixvec.less_than()
      • sbitfixvec.max()
      • sbitfixvec.min()
      • sbitfixvec.not_equal()
      • sbitfixvec.reveal()
      • sbitfixvec.round_nearest
      • sbitfixvec.set_precision()
      • sbitfixvec.square()
      • sbitfixvec.store_in_mem()
      • sbitfixvec.update()
    • sbitintvec
      • sbitintvec.bit_and()
      • sbitintvec.bit_not()
      • sbitintvec.bit_or()
      • sbitintvec.bit_xor()
      • sbitintvec.equal()
      • sbitintvec.from_hex()
      • sbitintvec.get_type()
      • sbitintvec.half_adder()
      • sbitintvec.iadd()
      • sbitintvec.max()
      • sbitintvec.min()
      • sbitintvec.popcnt()
      • sbitintvec.pow2()
      • sbitintvec.reveal_print_hex()
      • sbitintvec.square()
    • sbits
      • sbits.Array()
      • sbits.MemValue()
      • sbits.bit_adder()
      • sbits.bit_and()
      • sbits.bit_not()
      • sbits.bit_or()
      • sbits.bit_xor()
      • sbits.get_input_from()
      • sbits.get_type()
      • sbits.half_adder()
      • sbits.if_else()
      • sbits.popcnt()
      • sbits.update()
    • sbitvec
      • sbitvec.bit_and()
      • sbitvec.bit_not()
      • sbitvec.bit_or()
      • sbitvec.bit_xor()
      • sbitvec.equal()
      • sbitvec.from_hex()
      • sbitvec.get_type()
      • sbitvec.half_adder()
      • sbitvec.popcnt()
      • sbitvec.reveal_print_hex()
  • Compiler.library module
    • accept_client_connection()
    • break_loop()
    • break_point()
    • check_point()
    • crash()
    • do_while()
    • for_range()
    • for_range_multithread()
    • for_range_opt()
    • for_range_opt_multithread()
    • for_range_parallel()
    • foreach_enumerate()
    • function()
    • get_arg()
    • get_cmdline_arg()
    • get_number_of_players()
    • get_player_id()
    • get_thread_number()
    • get_threshold()
    • if_()
    • if_e()
    • init_client_connection()
    • listen_for_clients()
    • map_sum_opt()
    • map_sum_simple()
    • multithread()
    • print_both()
    • print_float_precision()
    • print_ln()
    • print_ln_if()
    • print_ln_to()
    • print_str()
    • print_str_if()
    • public_input()
    • runtime_error()
    • runtime_error_if()
    • start_timer()
    • stop_timer()
    • tree_reduce()
    • tree_reduce_multithread()
    • while_do()
  • Compiler.mpc_math module
    • atan()
    • acos()
    • asin()
    • cos()
    • exp2_fx()
    • InvertSqrt()
    • log2_fx()
    • log_fx()
    • pow_fx()
    • sin()
    • sqrt()
    • tan()
    • tanh()
  • Compiler.ml module
    • Adam
      • Adam.backward()
      • Adam.eval()
      • Adam.fit()
      • Adam.forward()
      • Adam.layers
      • Adam.reset()
      • Adam.reveal_correctness()
      • Adam.reveal_model_to_binary()
      • Adam.run()
      • Adam.set_layers_with_inputs()
      • Adam.trainable_variables
    • Add
    • Argmax
    • BatchNorm
    • Concat
    • Dense
    • Dropout
    • FixAveragePool2d
    • FixConv2d
    • FusedBatchNorm
    • Gelu
      • Gelu.prime_type
    • LayerNorm
    • MaxPool
    • MultiOutput
    • Optimizer
      • Optimizer.backward()
      • Optimizer.eval()
      • Optimizer.fit()
      • Optimizer.forward()
      • Optimizer.layers
      • Optimizer.reset()
      • Optimizer.reveal_correctness()
      • Optimizer.reveal_model_to_binary()
      • Optimizer.run()
      • Optimizer.set_layers_with_inputs()
      • Optimizer.trainable_variables
    • Output
    • Relu
      • Relu.prime_type
    • ReluMultiOutput
    • SGD
      • SGD.backward()
      • SGD.eval()
      • SGD.fit()
      • SGD.forward()
      • SGD.layers
      • SGD.reset()
      • SGD.reveal_correctness()
      • SGD.reveal_model_to_binary()
      • SGD.run()
      • SGD.set_layers_with_inputs()
      • SGD.trainable_variables
    • SGDLinear
      • SGDLinear.fit()
      • SGDLinear.fit_with_testing()
      • SGDLinear.predict()
    • SGDLogistic
      • SGDLogistic.fit()
      • SGDLogistic.fit_with_testing()
      • SGDLogistic.predict()
      • SGDLogistic.predict_proba()
    • Square
      • Square.prime_type
    • TwoQuadOutput
    • argmax()
    • cholesky()
    • easyConv2d()
    • easyMaxPool()
    • layers_from_torch()
    • mr()
    • relu()
    • relu_prime()
    • sigmoid()
    • sigmoid_prime()
    • softmax()
    • solve_cholesky()
    • solve_linear()
    • solve_lower()
    • solve_upper()
    • var()
    • approx_sigmoid()
  • Compiler.decision_tree module
    • TreeClassifier
      • TreeClassifier.fit()
      • TreeClassifier.fit_with_testing()
      • TreeClassifier.output()
      • TreeClassifier.predict()
    • TreeTrainer
      • TreeTrainer.train()
      • TreeTrainer.train_with_testing()
    • output_decision_tree()
    • preprocess_pandas()
    • run_decision_tree()
  • Compiler.circuit module
    • Circuit
    • ieee_float
    • sha256()
    • sha3_256()
  • Compiler.program module
    • Program
      • Program.active
      • Program.join_tapes()
      • Program.new_tape()
      • Program.options_from_args()
      • Program.protect_memory()
      • Program.public_input()
      • Program.run_tapes()
      • Program.security
      • Program.set_bit_length()
      • Program.use_dabit
      • Program.use_edabit()
      • Program.use_invperm()
      • Program.use_split()
      • Program.use_square()
      • Program.use_trunc_pr
  • Compiler.oram module
    • LinearORAM
    • OptimalORAM()
    • RecursiveORAM
      • RecursiveORAM.index_structure
  • Compiler.sqrt_oram module
    • SqrtOram
  • Compiler.path_oblivious_heap module
    • POHToHeapQAdapter
      • POHToHeapQAdapter.extract_min()
      • POHToHeapQAdapter.find_min()
      • POHToHeapQAdapter.insert()
      • POHToHeapQAdapter.pop()
      • POHToHeapQAdapter.update()
    • PathObliviousHeap
      • PathObliviousHeap.extract_min()
      • PathObliviousHeap.find_min()
      • PathObliviousHeap.insert()
    • UniquePOHToHeapQAdapter
      • UniquePOHToHeapQAdapter.extract_min()
      • UniquePOHToHeapQAdapter.find_min()
      • UniquePOHToHeapQAdapter.insert()
      • UniquePOHToHeapQAdapter.pop()
      • UniquePOHToHeapQAdapter.update()
    • UniquePathObliviousHeap
      • UniquePathObliviousHeap.extract_min()
      • UniquePathObliviousHeap.find_min()
      • UniquePathObliviousHeap.insert()
      • UniquePathObliviousHeap.update()
    • path_oblivious_sort()
  • Compiler.dijkstra module
    • convert_graph()
    • dijkstra()
    • test_dijkstra()
  • Compiler.sorting module
    • radix_sort()
    • reveal_sort()
• 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
    • acceptclientconnection
    • active
    • addc
    • addci
    • addint
      • addint.op()
    • addm
    • adds
    • addsi
    • andc
    • andci
    • applyshuffle
    • asm_open
    • bit
    • bitdecint
    • call_arg
    • call_tape
      • call_tape.get_def()
      • call_tape.get_used()
    • check
    • cisc
    • closeclientconnection
    • cmdlinearg
    • concats
    • cond_print_plain
    • cond_print_str
    • conv2ds
    • convint
    • convmodp
    • crash
    • dabit
    • delshuffle
    • digestc
    • divc
    • divci
    • divint
      • divint.op()
    • dotprods
      • dotprods.get_def()
      • dotprods.get_used()
    • edabit
    • eqc
      • eqc.op()
    • eqzc
    • file_base
    • fixinput
    • floatoutput
    • floordivc
    • gensecshuffle
    • gtc
      • gtc.op()
    • incint
    • initclientconnection
    • inputfix
    • inputfloat
    • inputmask
    • inputmaskreg
    • inputmixed
    • inputmixedreg
    • inputpersonal
    • intoutput
    • inv2m
    • inverse
    • inverse_permutation
    • jmp
    • jmpeqz
    • jmpi
    • jmpnz
    • join_tape
    • ldarg
    • ldi
    • ldint
    • ldmc
    • ldmci
      • ldmci.direct
    • ldmint
    • ldminti
      • ldminti.direct
    • ldms
    • ldmsi
      • ldmsi.direct
    • ldsi
    • ldtn
    • legendrec
    • listen
    • ltc
      • ltc.op()
    • ltzc
    • matmuls
    • matmulsm
    • modc
    • modci
    • movc
    • movint
    • movs
    • mul_base
    • mulc
    • mulci
    • mulint
      • mulint.op()
    • mulm
    • mulrs
      • mulrs.get_def()
      • mulrs.get_used()
    • muls
    • mulsi
    • notc
    • nplayers
    • orc
    • orci
    • personal_base
    • picks
    • playerid
    • popint
    • prefixsums
    • prep
    • print_char
    • print_char4
    • print_float_plain
    • print_float_prec
    • print_int
    • print_reg
    • print_reg_plain
    • print_reg_plains
    • privateoutput
    • pubinput
    • pushint
    • rand
    • randomfulls
    • randoms
    • rawinput
    • readfileclear
    • readsharesfromfile
    • readsocketc
    • readsocketint
    • readsockets
    • reqbl
    • run_tape
    • secshuffle
    • sedabit
    • sendpersonal
    • shlc
    • shlci
    • shrc
    • shrci
    • shrsi
    • shuffle
    • shuffle_base
    • square
    • starg
    • start
    • stmc
    • stmci
      • stmci.direct
    • stmint
    • stminti
      • stminti.direct
    • stms
    • stmsi
      • stmsi.direct
    • stop
    • subc
    • subcfi
    • subci
    • subint
      • subint.op()
    • subml
    • submr
    • subs
    • subsfi
    • subsi
    • threshold
    • time
    • triple
    • trunc_pr
    • unsplit
    • use
    • use_edabit
    • use_inp
    • use_matmul
    • use_prep
    • writefileclear
    • writesharestofile
    • writesockets
    • writesocketshare
    • xorc
    • xorci
    • zips
  • Compiler.GC.instructions module
    • BinaryCiscable
    • addcb
    • addcbi
    • andm
    • andrs
    • andrsvec
    • ands
    • bitb
    • bitcoms
    • bitdecc
    • bitdecs
    • cond_print_strb
    • convcbit
    • convcbit2s
    • convcbitvec
    • convcint
    • convcintvec
    • convsint
    • inputb
    • inputbvec
    • ldbits
    • ldmcb
    • ldmcbi
      • ldmcbi.direct
    • ldmsb
    • ldmsbi
      • ldmsbi.direct
    • movsb
    • mulcbi
    • notcb
    • nots
    • print_float_plainb
    • print_reg_plainb
    • print_reg_plainsb
    • print_reg_signed
    • print_regb
    • reveal
    • shlcbi
    • shrcbi
    • split
    • stmcb
    • stmcbi
      • stmcbi.direct
    • stmsb
    • stmsbi
      • stmsbi.direct
    • trans
    • xorcb
    • xorcbi
    • xorm
    • xors
• Low-Level Interface
  • Thread Safety
  • Domain Types
  • Share Types
  • Protocol Setup
    • ProtocolSetup
      • ProtocolSetup()
      • ProtocolSetup()
      • set_batch_size()
    • ProtocolSet
      • ProtocolSet()
      • ProtocolSet()
      • check()
    • BinaryProtocolSetup
      • BinaryProtocolSetup()
    • BinaryProtocolSet
      • BinaryProtocolSet()
      • BinaryProtocolSet()
      • check()
    • MixedProtocolSetup
      • MixedProtocolSetup()
    • MixedProtocolSet
      • MixedProtocolSet()
      • MixedProtocolSet()
      • check()
  • Protocol Interfaces
    • ProtocolBase
      • mul()
      • init()
      • init_mul()
      • prepare_mul()
      • exchange()
      • finalize_mul()
      • finalize_mult()
      • init_dotprod()
      • prepare_dotprod()
      • next_dotprod()
      • finalize_dotprod()
    • InputBase
      • reset()
      • reset_all()
      • add_mine()
      • add_other()
      • add_from_all()
      • exchange()
      • finalize()
    • MAC_Check_Base
      • Check()
      • get_alphai()
      • POpen()
      • open()
      • init_open()
      • prepare_open()
      • exchange()
      • finalize_open()
      • CheckFor()
    • Preprocessing
      • get_triple()
      • get_bit()
      • get_random()
      • get_dabit()
      • get_edabitvec()
      • basic_setup()
      • setup()
      • teardown()
    • BufferPrep
      • get_edabitvec()
      • get_random()
      • basic_setup()
      • setup()
      • teardown()
  • Domain Reference
    • gfp_
      • gfp_()
      • gfp_()
      • gfp_()
      • sqrRoot()
      • randomize()
      • output()
      • pack()
      • unpack()
      • init_field()
      • init_default()
      • pr()
      • operator<<
      • operator>>
    • gfpvar_
    • Z2
    • SignedZ2
      • SignedZ2()
      • SignedZ2()
    • bigint
      • bigint()
      • bigint()
      • bigint()
      • bigint()
      • bigint()
      • from_signed()
• Using High-Level Functionality in C++
  • Vector arguments and return values
  • Binary values
  • C++ compilation
  • Reference
    • FunctionArgument
      • FunctionArgument()
      • FunctionArgument()
      • FunctionArgument()
      • FunctionArgument()
• 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
      • Names
      • Player
      • MultiPlayer
      • PlainPlayer
      • CryptoPlayer
      • octetStream
• 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
    • Client
      • Client.receive_outputs()
      • Client.receive_plain_values()
      • Client.send_private_inputs()
      • Client.send_public_inputs()
  • C++ Reference
    • Client
      • Client()
      • send_private_inputs()
      • receive_outputs()
      • sockets
      • specification
• 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
    • PRNG
      • PRNG()
      • PRNG()
      • PRNG()
      • ReSeed()
      • SeedGlobally()
      • SetSeed()
      • SetSeed()
      • get_bit()
      • get_uchar()
      • get_uint()
      • get_uint()
      • randomBnd()
      • get_word()
      • get_doubleword()
      • get_octets()
      • get_octets()
      • get()
    • SeededPRNG
    • GlobalPRNG
• Adding an Instruction
  • Frontend
  • Backend
    • Parsing
    • Resourcing
    • Execution
• Homomorphic Encryption
  • Reference
    • FHE_Params
      • FHE_Params()
      • pack()
      • unpack()
      • basic_generation_mod_prime()
    • FHE_KeyPair
      • FHE_KeyPair()
      • generate()
      • pk
      • sk
    • FHE_SK
      • pack()
      • unpack()
      • decrypt()
    • FHE_PK
      • encrypt()
      • pack()
      • unpack()
    • Plaintext
      • num_slots()
      • Plaintext()
      • element()
      • set_element()
      • pack()
      • unpack()
    • Ciphertext
      • mul()
      • rerandomize()
      • pack()
      • unpack()
• Threshold ECDSA
  • Compilation
  • Running
• Security Fixes
  • Malicious parties are not committed to MAC key across threads and executions
  • Insufficient checks in Rep4
  • Co-ordinate MAC checks among threads and race condition in MAC checks
  • Remove MAC key in case of failure
  • Remotely caused buffer overflows
  • Missing shuffling check in PS mod 2^k and Brain
  • Insufficient drowning in pairwise protocols
  • Proper accounting for random elements
  • Insufficient security in non-interactive zero-knowledge proofs
  • Security bug in SPDZ2k
  • Skewed random bit generation
  • All-zero secret keys in homomorphic encryption
  • Insufficient randomness in SemiBin random bit generation
  • Missing MAC key initialization
• 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
  • Cannot branch on secret values
  • 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