Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/zama-ai/tfhe-rs

TFHE-rs: A Pure Rust implementation of the TFHE Scheme for Boolean and Integer Arithmetics Over Encrypted Data.
https://github.com/zama-ai/tfhe-rs

cryptography homomorphic-encryption rust tfhe

Last synced: 2 months ago
JSON representation

TFHE-rs: A Pure Rust implementation of the TFHE Scheme for Boolean and Integer Arithmetics Over Encrypted Data.

Host: GitHub
URL: https://github.com/zama-ai/tfhe-rs
Owner: zama-ai
License: other
Created: 2022-10-13T09:20:07.000Z (about 2 years ago)
Default Branch: main
Last Pushed: 2024-10-29T09:53:24.000Z (2 months ago)
Last Synced: 2024-10-29T09:54:40.328Z (2 months ago)
Topics: cryptography, homomorphic-encryption, rust, tfhe
Language: Rust
Homepage:
Size: 18.2 MB
Stars: 931
Watchers: 18
Forks: 144
Open Issues: 24
Metadata Files:
- Readme: README.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md

Awesome Lists containing this project

awesome-zama - TFHE-rs
awesome-cryptography-rust - TFHE-rs
awesome-fhe - TFHE-rs
awesome-he - TFHE-rs - Rust implementation of the TFHE scheme for boolean and integers FHE arithmetics by [Zama](https://github.com/zama-ai). (Libraries)

README

        


  

  

  







   📒 Documentation |  💛 Community support |  📚 FHE resources by Zama





  

  

  



## About

### What is TFHE-rs

**TFHE-rs** is a pure Rust implementation of TFHE for boolean and integer arithmetics over encrypted data.

It includes:

- a **Rust** API

- a **C** API

- and a **client-side WASM** API

TFHE-rs is designed for developers and researchers who want full control over

what they can do with TFHE, while not having to worry about the low-level

implementation. The goal is to have a stable, simple, high-performance, and

production-ready library for all the advanced features of TFHE.




### Main features

- **Low-level cryptographic library** that implements Zama’s variant of TFHE, including programmable bootstrapping

- **Implementation of the original TFHE boolean API** that can be used as a drop-in replacement for other TFHE libraries

- **Short integer API** that enables exact, unbounded FHE integer arithmetics with up to 8 bits of message space

- **Size-efficient public key encryption**

- **Ciphertext and server key compression** for efficient data transfer

- **Full Rust API, C bindings to the Rust High-Level API, and client-side Javascript API using WASM**.

*Learn more about TFHE-rs features in the [documentation](https://docs.zama.ai/tfhe-rs/readme).*




## Table of Contents

- **[Getting started](#getting-started)**

   - [Cargo.toml configuration](#cargotoml-configuration)

   - [A simple example](#a-simple-example)

- **[Resources](#resources)**

   - [TFHE deep dive](#tfhe-deep-dive)

   - [Tutorials](#tutorials)

   - [Documentation](#documentation)

- **[Working with TFHE-rs](#working-with-tfhe-rs)**

   - [Disclaimers](#disclaimers)

   - [Citations](#citations)

   - [Contributing](#contributing)

   - [License](#license)

- **[Support](#support)**




## Getting started

### Cargo.toml configuration

To use the latest version of `TFHE-rs` in your project, you first need to add it as a dependency in your `Cargo.toml`:

+ For x86_64-based machines running Unix-like OSes:

```toml

tfhe = { version = "*", features = ["boolean", "shortint", "integer", "x86_64-unix"] }

```

+ For Apple Silicon or aarch64-based machines running Unix-like OSes:

```toml

tfhe = { version = "*", features = ["boolean", "shortint", "integer", "aarch64-unix"] }

```

+ For x86_64-based machines with the [`rdseed instruction`](https://en.wikipedia.org/wiki/RDRAND) running Windows:

```toml

tfhe = { version = "*", features = ["boolean", "shortint", "integer", "x86_64"] }

```

> [!Note]

> Note: You need to use a Rust version >= 1.73 to compile TFHE-rs.

> [!Note]

> Note: aarch64-based machines are not yet supported for Windows as it's currently missing an entropy source to be able to seed the [CSPRNGs](https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator) used in TFHE-rs.



   ↑ Back to top  



### A simple example

Here is a full example:

``` rust

use tfhe::prelude::*;

use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint32, FheUint8};

fn main() -> Result<(), Box> {

    // Basic configuration to use homomorphic integers

    let config = ConfigBuilder::default().build();

    // Key generation

    let (client_key, server_keys) = generate_keys(config);

    let clear_a = 1344u32;

    let clear_b = 5u32;

    let clear_c = 7u8;

    // Encrypting the input data using the (private) client_key

    // FheUint32: Encrypted equivalent to u32

    let mut encrypted_a = FheUint32::try_encrypt(clear_a, &client_key)?;

    let encrypted_b = FheUint32::try_encrypt(clear_b, &client_key)?;

    // FheUint8: Encrypted equivalent to u8

    let encrypted_c = FheUint8::try_encrypt(clear_c, &client_key)?;

    // On the server side:

    set_server_key(server_keys);

    // Clear equivalent computations: 1344 * 5 = 6720

    let encrypted_res_mul = &encrypted_a * &encrypted_b;

    // Clear equivalent computations: 6720 >> 5 = 210

    encrypted_a = &encrypted_res_mul >> &encrypted_b;

    // Clear equivalent computations: let casted_a = a as u8;

    let casted_a: FheUint8 = encrypted_a.cast_into();

    // Clear equivalent computations: min(210, 7) = 7

    let encrypted_res_min = &casted_a.min(&encrypted_c);

    // Operation between clear and encrypted data:

    // Clear equivalent computations: 7 & 1 = 1

    let encrypted_res = encrypted_res_min & 1_u8;

    // Decrypting on the client side:

    let clear_res: u8 = encrypted_res.decrypt(&client_key);

    assert_eq!(clear_res, 1_u8);

    Ok(())

}

```

To run this code, use the following command: 

  cargo run --release  


> [!Note]

> Note that when running code that uses `TFHE-rs`, it is highly recommended

to run in release mode with cargo's `--release` flag to have the best performances possible.

*Find an example with more explanations in [this part of the documentation](https://docs.zama.ai/tfhe-rs/get-started/quick_start)*



   ↑ Back to top  



## Resources 

### TFHE deep dive

- [TFHE Deep Dive - Part I - Ciphertext types](https://www.zama.ai/post/tfhe-deep-dive-part-1)

- [TFHE Deep Dive - Part II - Encodings and linear leveled operations](https://www.zama.ai/post/tfhe-deep-dive-part-2)

- [TFHE Deep Dive - Part III - Key switching and leveled multiplications](https://www.zama.ai/post/tfhe-deep-dive-part-3)

- [TFHE Deep Dive - Part IV - Programmable Bootstrapping](https://www.zama.ai/post/tfhe-deep-dive-part-4)




### Tutorials

- [[Video tutorial] Implement signed integers using TFHE-rs ](https://www.zama.ai/post/video-tutorial-implement-signed-integers-ssing-tfhe-rs)

- [Homomorphic parity bit](https://docs.zama.ai/tfhe-rs/tutorials/parity_bit)

- [Homomorphic case changing on Ascii string](https://docs.zama.ai/tfhe-rs/tutorials/ascii_fhe_string)

- [Boolean SHA256 with TFHE-rs](https://www.zama.ai/post/boolean-sha256-tfhe-rs)

- [Dark market with TFHE-rs](https://www.zama.ai/post/dark-market-tfhe-rs)

- [Regular expression engine with TFHE-rs](https://www.zama.ai/post/regex-engine-tfhe-rs)

*Explore more useful resources in [TFHE-rs tutorials](https://docs.zama.ai/tfhe-rs/tutorials) and [Awesome Zama repo](https://github.com/zama-ai/awesome-zama)*




### Documentation

Full, comprehensive documentation is available here: [https://docs.zama.ai/tfhe-rs](https://docs.zama.ai/tfhe-rs).



   ↑ Back to top  



## Working with TFHE-rs

### Disclaimers

#### Security estimation

Security estimations are done using the

[Lattice Estimator](https://github.com/malb/lattice-estimator)

with `red_cost_model = reduction.RC.BDGL16`.

When a new update is published in the Lattice Estimator, we update parameters accordingly.

### Security model

The default parameters for the TFHE-rs library are chosen considering the IND-CPA security model, and are selected with a bootstrapping failure probability fixed at p_error = $2^{-64}$. In particular, it is assumed that the results of decrypted computations are not shared by the secret key owner with any third parties, as such an action can lead to leakage of the secret encryption key. If you are designing an application where decryptions must be shared, you will need to craft custom encryption parameters which are chosen in consideration of the IND-CPA^D security model [1]. 

[1] Li, Baiyu, et al. "Securing approximate homomorphic encryption using differential privacy." Annual International Cryptology Conference. Cham: Springer Nature Switzerland, 2022. https://eprint.iacr.org/2022/816.pdf

#### Side-channel attacks

Mitigation for side-channel attacks has not yet been implemented in TFHE-rs,

and will be released in upcoming versions.




### Citations

To cite TFHE-rs in academic papers, please use the following entry:

```text

@Misc{TFHE-rs,

  title={{TFHE-rs: A Pure Rust Implementation of the TFHE Scheme for Boolean and Integer Arithmetics Over Encrypted Data}},

  author={Zama},

  year={2022},

  note={\url{https://github.com/zama-ai/tfhe-rs}},

}

```

### Contributing

There are two ways to contribute to TFHE-rs:

- [Open issues](https://github.com/zama-ai/tfhe-rs/issues/new/choose) to report bugs and typos, or to suggest new ideas

- Request to become an official contributor by emailing [[email protected]](mailto:[email protected]).

Becoming an approved contributor involves signing our Contributor License Agreement (CLA). Only approved contributors can send pull requests, so please make sure to get in touch before you do!




### License

This software is distributed under the **BSD-3-Clause-Clear** license. Read [this](LICENSE) for more details.

#### FAQ

**Is Zama’s technology free to use?**

>Zama’s libraries are free to use under the BSD 3-Clause Clear license only for development, research, prototyping, and experimentation purposes. However, for any commercial use of Zama's open source code, companies must purchase Zama’s commercial patent license.

>

>Everything we do is open source and we are very transparent on what it means for our users, you can read more about how we monetize our open source products at Zama in [this blogpost](https://www.zama.ai/post/open-source).

**What do I need to do if I want to use Zama’s technology for commercial purposes?**

>To commercially use Zama’s technology you need to be granted Zama’s patent license. Please contact us [email protected] for more information.

**Do you file IP on your technology?**

>Yes, all Zama’s technologies are patented.

**Can you customize a solution for my specific use case?**

>We are open to collaborating and advancing the FHE space with our partners. If you have specific needs, please email us at [email protected].



   ↑ Back to top  



## Support



  

  

  



🌟 If you find this project helpful or interesting, please consider giving it a star on GitHub! Your support helps to grow the community and motivates further development. 



   ↑ Back to top