1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
#![allow(clippy::excessive_precision)]
//! Welcome the the `concrete-shortint` documentation!
//!
//! # Description
//!
//! This library makes it possible to execute modular operations over encrypted short integer.
//!
//! It allows to execute an integer circuit on an untrusted server because both circuit inputs and
//! 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.
//!
//! The server however, has to know the integer circuit to be evaluated.
//! At the end of the computation, the server returns the encryption of the result to the user.
//!
//! # Keys
//!
//! This crates exposes two type of keys:
//! * The [ClientKey] is used to encrypt and decrypt and has to be kept secret;
//! * The [ServerKey] is used to perform homomorphic operations on the server side and it is meant
//! to be published (the client sends it to the server).
//!
//!
//! # Quick Example
//!
//! The following piece of code shows how to generate keys and run a small integer circuit
//! homomorphically.
//!
//! ```rust
//! use concrete_shortint::{gen_keys, Parameters};
//!
//! // We generate a set of client/server keys, using the default parameters:
//! let (mut client_key, mut server_key) = gen_keys(Parameters::default());
//!
//! let msg1 = 1;
//! let msg2 = 0;
//!
//! // We use the client key to encrypt two messages:
//! let ct_1 = client_key.encrypt(msg1);
//! let ct_2 = client_key.encrypt(msg2);
//!
//! // We use the server public key to execute an integer circuit:
//! let ct_3 = server_key.unchecked_add(&ct_1, &ct_2);
//!
//! // We use the client key to decrypt the output of the circuit:
//! let output = client_key.decrypt(&ct_3);
//! assert_eq!(output, 1);
//! ```
pub mod ciphertext;
pub mod client_key;
pub mod engine;
#[cfg(any(test, feature = "internal-keycache"))]
pub mod keycache;
pub mod parameters;
pub mod server_key;
#[cfg(doctest)]
mod test_user_docs;
pub mod wopbs;
pub use ciphertext::Ciphertext;
pub use client_key::ClientKey;
pub use parameters::Parameters;
pub use server_key::{CheckError, ServerKey};
/// Generate a couple of client and server keys.
///
/// # Example
///
/// Generating a pair of [ClientKey] and [ServerKey] using the default parameters.
///
/// ```rust
/// use concrete_shortint::gen_keys;
///
/// // generate the client key and the server key:
/// let (cks, sks) = gen_keys(Default::default());
/// ```
pub fn gen_keys(parameters_set: Parameters) -> (ClientKey, ServerKey) {
let cks = ClientKey::new(parameters_set);
let sks = ServerKey::new(&cks);
(cks, sks)
}