#fully #homomorphic #encryption #fhe #cryptography


Homomorphic Integer circuit interface for the concrete FHE library

1 unstable release

0.1.0-beta.0 Jul 6, 2022

#896 in Cryptography

45 downloads per month

BSD-3-Clause-Clear and GPL-2.0-or-later

10K SLoC

concrete Integer

concrete-integer is a Rust library built on top of concrete-shortint, it combines multiple shortint to handle encrypted integers of "arbitrary" size.


This software is distributed under the BSD-3-Clause-Clear license. If you have any questions, please contact us at hello@zama.ai.


Welcome the the concrete-integer documentation!


This library makes it possible to execute modular operations over encrypted integer.

It allows to execute an integer circuit on an untrusted server because both circuit inputs outputs are kept private.

Data are encrypted on the client side, before being sent to the server. On the server side every computation is performed on ciphertexts

Quick Example

The following piece of code shows how to generate keys and run a integer circuit homomorphically.

use concrete_integer::gen_keys;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

//4 blocks for the radix decomposition
let number_of_blocks = 4;
// Modulus = (2^2)*4 = 2^8 (from the parameters chosen and the number of blocks
let modulus = 1 << 8;

// Generation of the client/server keys, using the default parameters:
let (mut client_key, mut server_key) = gen_keys(&PARAM_MESSAGE_2_CARRY_2, number_of_blocks);

let msg1 = 153;
let msg2 = 125;

// Encryption of two messages using the client key:
let ct_1 = client_key.encrypt(msg1);
let ct_2 = client_key.encrypt(msg2);

// Homomorphic evaluation of an integer circuit (here, an addition) using the server key:
let ct_3 = server_key.unchecked_add(&ct_1, &ct_2);

// Decryption of the ciphertext using the client key:
let output = client_key.decrypt(&ct_3);
assert_eq!(output, (msg1 + msg2) % modulus);


This uses cryptographic parameters from the concrete-shortint crates. Currently, the radix approach is only compatible with parameter sets such that the message and carry buffers have the same size.


~426K SLoC