concrete 0.1.4

Concrete is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.
Documentation

Concrete Operates oN Ciphertexts Rapidly by Extending TfhE

Concrete is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE. Concrete is based on the Learning With Errors (LWE) problem and on the Ring Learning With Errors (RLWE) problem, which are well studied cryptographic hardness assumptions believed to be secure even against quantum computers.

To use Concrete, you must install Rust, FFTW and add concrete to the list of dependencies.

Links

Rust installation

To install rust on Linux or Macos, you can do the following:

curl  --tlsv1.2 -sSf https://sh.rustup.rs | sh

If you want other rust installation methods, please refer to rust website.

FFTW and openssl installation

You also need to install FFTW and openssl library.

MacOS

The more straightforward way to install fftw is to use Homebrew Formulae. To install homebrew, you can do the following:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

And then install FFTW and openssl.

brew install fftw
brew install openssl

Linux

To install FFTW on a debian-based distribution, you can do the following:

sudo apt-get update && sudo apt-get install -y libfftw3-dev libssl-dev

From source

If you want to install FFTW directly from source, you can follow the steps described in FFTW's website.

It is also possible to build the library from source by cloning this repository and running:

cd concrete
make build

To run the tests, you can do the following

cd concrete
make test

Use concrete in your own project

You can use cargo new play_with_fhe to create a new project. You need to add the Concrete library as a dependency in your Rust project.

To do so, simply add the dependency in the Cargo.toml file. Here is a simple example:

[package]
name = "play_with_fhe"
version = "0.1.0"
authors = ["FHE Curious"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
concrete = "^0.1"

Now, you can run your project with the RUSTFLAGS="-C target-cpu=native" cargo run --release command.

Example

use concrete::*;

fn main() -> Result<(), CryptoAPIError> {
    // generate a secret key
    let secret_key = LWESecretKey::new(&LWE128_630);

    // the two values to add
    let m1 = 8.2;
    let m2 = 5.6;

    // specify the range and precision to encode messages into plaintexts
    // here we encode in [0, 10[ with 8 bits of precision and 1 bit of padding
    let encoder = Encoder::new(0., 10., 8, 1)?;

    // encode the messages into plaintexts
    let p1 = encoder.encode_single(m1)?;
    let p2 = encoder.encode_single(m2)?;

    // encrypt plaintexts
    let mut c1 = VectorLWE::encrypt(&secret_key, &p1)?;
    let c2 = VectorLWE::encrypt(&secret_key, &p2)?;

    // add the two ciphertexts homomorphically
    c1.add_with_padding_inplace(&c2)?;

    // decrypt and decode the result
    let m3 = c1.decrypt_decode(&secret_key)?;

    // print the result and compare to non-FHE addition
    println!("Real: {} + {} = {}", m1, m2, m1 + m2);
    println!(
        "FHE: {} + {} = {}",
        p1.decode()?[0],
        p2.decode()?[0],
        m3[0]
    );
 Ok(())
}

Credits

This library uses several dependencies and we would like to thank the contributors of those libraries :

We also use some crates published by The Rust Project Developers under the MIT or Apache 2.0 license :

We thank Daniel May for supporting this project and donating the Concrete crate.

License

This software is distributed under the AGPL-v3 license. If you have any question, please contact us at hello@zama.ai.