tfhe 1.6.0

TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.
Documentation 
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
84

use serde::{Deserialize, Serialize};
use tfhe_versionable::Versionize;

use ks32::KS32AtomicPatternNoiseSquashingKey;
use standard::StandardAtomicPatternNoiseSquashingKey;

use crate::core_crypto::prelude::CiphertextModulus as CoreCiphertextModulus;
use crate::shortint::backward_compatibility::noise_squashing::AtomicPatternNoiseSquashingKeyVersions;
use crate::shortint::ciphertext::SquashedNoiseCiphertext;
use crate::shortint::client_key::atomic_pattern::AtomicPatternClientKey;
use crate::shortint::server_key::ServerKeyView;
use crate::shortint::{CarryModulus, Ciphertext, MessageModulus};

use super::NoiseSquashingPrivateKey;

pub mod compressed;
pub mod expanded;
pub mod ks32;
pub mod standard;

pub use expanded::ExpandedAtomicPatternNoiseSquashingKey;

pub trait NoiseSquashingAtomicPattern {
    fn squash_ciphertext_noise(
        &self,
        ciphertext: &Ciphertext,
        src_server_key: ServerKeyView,
        output_message_modulus: MessageModulus,
        output_carry_modulus: CarryModulus,
        output_ciphertext_modulus: CoreCiphertextModulus<u128>,
    ) -> crate::Result<SquashedNoiseCiphertext>;
}

/// The noise squashing key materials for all the supported Atomic Patterns
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Versionize)]
#[versionize(AtomicPatternNoiseSquashingKeyVersions)]
pub enum AtomicPatternNoiseSquashingKey {
    Standard(StandardAtomicPatternNoiseSquashingKey),
    KeySwitch32(KS32AtomicPatternNoiseSquashingKey),
}

impl AtomicPatternNoiseSquashingKey {
    pub fn new(
        cks: &AtomicPatternClientKey,
        noise_squashing_private_key: &NoiseSquashingPrivateKey,
    ) -> Self {
        match cks {
            AtomicPatternClientKey::Standard(std_cks) => Self::Standard(
                StandardAtomicPatternNoiseSquashingKey::new(std_cks, noise_squashing_private_key),
            ),
            AtomicPatternClientKey::KeySwitch32(ks32_cks) => Self::KeySwitch32(
                KS32AtomicPatternNoiseSquashingKey::new(ks32_cks, noise_squashing_private_key),
            ),
        }
    }
}

impl NoiseSquashingAtomicPattern for AtomicPatternNoiseSquashingKey {
    fn squash_ciphertext_noise(
        &self,
        ciphertext: &Ciphertext,
        src_server_key: ServerKeyView,
        output_message_modulus: MessageModulus,
        output_carry_modulus: CarryModulus,
        output_ciphertext_modulus: CoreCiphertextModulus<u128>,
    ) -> crate::Result<SquashedNoiseCiphertext> {
        match self {
            Self::Standard(std_nsk) => std_nsk.squash_ciphertext_noise(
                ciphertext,
                src_server_key,
                output_message_modulus,
                output_carry_modulus,
                output_ciphertext_modulus,
            ),
            Self::KeySwitch32(ks32_nsk) => ks32_nsk.squash_ciphertext_noise(
                ciphertext,
                src_server_key,
                output_message_modulus,
                output_carry_modulus,
                output_ciphertext_modulus,
            ),
        }
    }
}