Secure transport for running MPC protocols backed by Signal

Last update: Jan 4, 2023

Related tags

Overview

MPC over Signal

Overview

This library provides a high-level interface for connecting to Signal Server and using it to exchange messages with other connected nodes (parties). Together with round_based crate, it allows you running any MPC protocol that implements round_based::StateMachine over secure transport backed by Signal.

Here is a demo showing how to use this library to run threshold BLS keygen & signing. For more details read our blog as well.

Self-hosted Signal Server

In order to be more confident in the server and to reduce the load on the original Signal Server, better option would be using self hosted Signal Server. The Signal Server code is open source and there are unofficial instructions on deploying it (here, here). This library is designed to work with any Signal-compatible API.

How to use it

Construct SignalClient

It is first required to specify how to reach the Signal Server. If using the Signal messenger Server, then the default settings are enough:

let client = SignalClient::new()?;

In case of self-hosted Signal Server, address and CA certificate must be set:

let mut root_certs = rustls::RootCertStore::empty();
root_certs
    .add_pem_file(&mut &include_bytes!("path/to/certificate.pem")[..])?;

let mut tls_config = rustls::ClientConfig::new();
tls_config.root_store = root_certs;

let client = awc::Client::builder()
    .connector(
        awc::Connector::new()
            .rustls(tls_config.into())
            .finish())
    .finish();

let mut builder = SignalClient::builder()?;
builder
    .set_server_host("https://localhost:1234/")?
    .set_http_client(client);
let client = builder.finish();

Link with Signal account

To communicate through Signal, obviously you need to have a Signal account. This library can only link with existing accounts, creating a new one is out of scope. Process of linking is the same as logging in to Signal Desktop: it is done by scanning the QR code with a mobile app.

use futures::channel::oneshot;
use rand::rngs::OsRng;

let (provision_url_tx, provision_url) = oneshot::channel();
let device_future = signal_client
    .login(&mut OsRng, provision_url_tx, "MPC device");

Method login takes oneshot channel and fires it when it got a provision URL. Provision URL should be rendered as QR code and scanned with a phone (linked device). After it has been scanned, device_future completes, and you can obtain your Device:

let device: Device = device_future.await?;

Distribute Public Identities

Before the parties can talk with each other, they need to know all counter parties identities.

Obtain a local party's identity:

let me: ParticipantIdentity = device.me();

Distribute it among group of parties you want to communicate with and receive their identities. Then construct a group that will run an MPC protocol:

// Order doesn't matter. It must include local party's identity too.
let group = Group::new(vec![me, party2, party3]);

Start messaging

To construct a stream of incoming messages and sink for outgoing messages, call this:

let device = DeviceStore::new(device);

let mut binded_client = signal_client
    .start_listening_for_incoming_messages(device)
    .await?;
let (incoming, outgoing) = binded_client.join_computation(me.addr, group);

Now incoming and outgoing can be used to send or receive messages. Transmitting messages have type round_based::Msg<T> where T is any type implementing serde's Serialize and Deserialize traits.

To run an MPC protocol that implements round_based::StateMachine, use round_based::AsyncProtocol. See demo sources for details.

Supported Rust version

The only supported version is Rust Nightly 1.49.0. This is a limitation of libsignal-protocol crate.

License

MPC-over-Signal is released under the terms of the AGPLv3 license. See LICENSE for more information.

Development Process & Contact

This library is maintained by ZenGo-X. Contributions are highly welcomed! Besides GitHub issues and PRs, feel free to reach out by mail or join ZenGo X Telegram for discussions on code and research.

Cyg will help you to secure files in your repository directly using PGP encryption

cyg: Secure files in your repository Cyg will help you to secure files in your repository directly using PGP encryption. The name "cyg" was inspired b

2 Aug 31, 2022

Easy c̵̰͠r̵̛̠ö̴̪s̶̩̒s̵̭̀-t̶̲͝h̶̯̚r̵̺͐e̷̖̽ḁ̴̍d̶̖̔ ȓ̵͙ė̶͎ḟ̴͙e̸̖͛r̶̖͗ë̶̱́ṉ̵̒ĉ̷̥e̷͚̍ s̷̹͌h̷̲̉a̵̭͋r̷̫̊ḭ̵̊n̷̬͂g̵̦̃ f̶̻̊ơ̵̜ṟ̸̈́ R̵̞̋ù̵̺s̷̖̅ţ̸͗!̸̼͋

Rust S̵̓i̸̓n̵̉ I̴n̴f̶e̸r̵n̷a̴l mutability! Howdy, friendly Rust developer! Ever had a value get m̵̯̅ð̶͊v̴̮̾ê̴̼͘d away right under your nose just when

294 Dec 23, 2022

mpc, but implemented in Rust.

rsmpc mpc, but implemented in Rust. Note: This is not meant to be a direct implementation, there will be some differences. For example: I moved the op

7 Jun 8, 2022

Rosenpass is a formally verified, post-quantum secure VPN that uses WireGuard to transport the actual data.

Rosenpass README This repository contains A description of the Rosenpass protocol The reference implementation of the protocol – the rosenpass tool A

597 Mar 19, 2023

(Pre-Release Software) Secure, Encrypted, P2P chat written atop Warp, IPFS, LibP2P, Dioxus and many more awesome projects and protocols.

Uplink Privacy First, Modular, P2P messaging client built atop Warp. Uplink is written in pure Rust with a UI in Dioxus (which is also written in Rust

13 Jan 25, 2023

Secure mTLS and gRPC backed runtime daemon. Alternative to systemd. Written in Rust.

Auraed A runtime daemon written in Rust. Designed to run as pid 1 mTLS backed gRPC API over unix domain socket Run executables Run containers Run virt

57 Dec 22, 2022

Employ your built-in wetware pattern recognition and signal processing facilities to understand your network traffic

Nethoscope Employ your built-in wetware pattern recognition and signal processing facilities to understand your network traffic. Check video on how it

86 Dec 5, 2022

A thread-safe signal/slot library based on boost::signals2

About signals2 is a thread-safe signal/slot library based on the boost::signals2 C++ library. Signals are objects that contain a list of callback func

15 Dec 21, 2022

Tiny crate that allows to wait for a stop signal across multiple threads

Tiny crate that allows to wait for a stop signal across multiple threads. Helpful mostly in server applications that run indefinitely and need a signal for graceful shutdowns.

5 Dec 16, 2022

A modular command line digital signal processor built in rust

Ever wanted to pipe raw audio samples around in the terminal to impress your friends at a party? Well then, you've come to the right place.

13 Dec 15, 2022

MollySocket allows getting signal notifications via UnifiedPush.

MollySocket This software is still in alpha. MollySocket allows getting signal notifications via UnifiedPush. It works like a linked device, which doe

6 Dec 31, 2022

Easy to use cryptographic framework for data protection: secure messaging with forward secrecy and secure data storage. Has unified APIs across 14 platforms.

Themis provides strong, usable cryptography for busy people General purpose cryptographic library for storage and messaging for iOS (Swift, Obj-C), An

1.6k Dec 30, 2022

Comments

Unresolved import libsignal_protocol::SenderKeyName, HKDF

Hi Team,

I am currently trying to use the MPC library using signal but it seems that there are some missing imports (SenderKeyName, HKDF) from the library. I saw that there are a couple of changes made to the signal client library.

May I know if the library used in this repository is the right one ? Currently it is pulling from here:

[dependencies.libsignal-protocol] git = "https://github.com/signalapp/libsignal-client"

Many thanks in advance!

Erwin

opened by Rwinwij 1
Use libsignal-service-rs ?

Hey! Full disclosure: I'm one of the main people behind https://github.com/Michael-F-Bryan/libsignal-service-rs/. I wonder why you folks rolled your own, and what would be missing in our library such that we can help each other? We already have unidentified senders (#4), for instance.

Want to team up?

opened by rubdos 5
Custom Error type

Currently mpc-over-signal library uses anyhow::Error. It's good for prototyping, but generally it's preferred for a library to have custom Error types. This makes easier to reason about what can go wrong as good-defined Error type enumerates all the ways of getting an error. thiserror crate can be used.

opened by survived 0
Actors' code is too complicated

There're two actors that were introduced into the code to handle shared state more nicely. Though using actors pattern achieves its main goal here: no mutex or other sync primitives are used, code got very hard to read. I believe that the main reason why it looks odd is because of having long chains of .map() .then() methods in order to access to actor's state. Probably it would look better if it were written using this approach: Actors with Tokio

opened by survived 0

Secure transport for running MPC protocols backed by Signal

Related tags

Overview

MPC over Signal

Overview

Self-hosted Signal Server

How to use it

Construct SignalClient

Link with Signal account

Distribute Public Identities

Start messaging

Supported Rust version

License

Development Process & Contact

You might also like...

Cyg will help you to secure files in your repository directly using PGP encryption

Easy c̵̰͠r̵̛̠ö̴̪s̶̩̒s̵̭̀-t̶̲͝h̶̯̚r̵̺͐e̷̖̽ḁ̴̍d̶̖̔ ȓ̵͙ė̶͎ḟ̴͙e̸̖͛r̶̖͗ë̶̱́ṉ̵̒ĉ̷̥e̷͚̍ s̷̹͌h̷̲̉a̵̭͋r̷̫̊ḭ̵̊n̷̬͂g̵̦̃ f̶̻̊ơ̵̜ṟ̸̈́ R̵̞̋ù̵̺s̷̖̅ţ̸͗!̸̼͋

mpc, but implemented in Rust.

Rosenpass is a formally verified, post-quantum secure VPN that uses WireGuard to transport the actual data.

(Pre-Release Software) Secure, Encrypted, P2P chat written atop Warp, IPFS, LibP2P, Dioxus and many more awesome projects and protocols.

Secure mTLS and gRPC backed runtime daemon. Alternative to systemd. Written in Rust.

Employ your built-in wetware pattern recognition and signal processing facilities to understand your network traffic

A thread-safe signal/slot library based on boost::signals2

Tiny crate that allows to wait for a stop signal across multiple threads

A modular command line digital signal processor built in rust

MollySocket allows getting signal notifications via UnifiedPush.

Easy to use cryptographic framework for data protection: secure messaging with forward secrecy and secure data storage. Has unified APIs across 14 platforms.

ARM TrustZone-M example application in Rust, both secure world side and non-secure world side

User-friendly secure computation engine based on secure multi-party computation

A µTP (Micro/uTorrent Transport Library) library implemented in Rust

🥧 Savoury implementation of the QUIC transport protocol and HTTP/3

fftp is the "Fast File Transport Protocol". It transfers files quickly between computers on a network with low overhead.

Rust bindings to the Wolfram Symbolic Transport Protocol (WSTP)

CLI to query for public transport connections in switzerland

Comments

Unresolved import libsignal_protocol::SenderKeyName, HKDF

Use libsignal-service-rs ?

Custom Error type

Actors' code is too complicated

Owner

[ZenGo X]

A simple scanner that loops through ips and checks if a minecraft server is running on port 25565

Rust library for building and running BPF/eBPF modules

Checks whether the process is running as root/sudo/admin permission in Windows and Unix systems

Secure drive wipe

Secure multithreaded packet sniffer

Secure sandboxing system for untrusted code execution

Cross-platform Secure TUI Secret Locker

Secure and fast microVMs for serverless computing.

Secure storage for cryptographic secrets in Rust

Use Touch ID / Secure Enclave for SSH Authentication!