tfhe 1.6.1

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use super::base::FheBool;
use crate::high_level_api::booleans::inner::InnerBoolean;
use crate::high_level_api::global_state;
use crate::high_level_api::keys::InternalServerKey;
use crate::high_level_api::re_randomization::ReRandomizationMetadata;
#[cfg(feature = "gpu")]
use crate::integer::gpu::ciphertext::boolean_value::CudaBooleanBlock;
#[cfg(feature = "gpu")]
use crate::integer::gpu::ciphertext::{CudaIntegerRadixCiphertext, CudaUnsignedRadixCiphertext};
use crate::prelude::{FheDecrypt, FheTrivialEncrypt, FheTryEncrypt, FheTryTrivialEncrypt};
use crate::{ClientKey, CompressedPublicKey, PublicKey};

impl FheTryEncrypt<bool, ClientKey> for FheBool {
    type Error = crate::Error;

    fn try_encrypt(value: bool, key: &ClientKey) -> Result<Self, Self::Error> {
        let integer_client_key = &key.key.key;
        let mut ciphertext = Self::new(
            integer_client_key.encrypt_bool(value),
            key.tag.clone(),
            ReRandomizationMetadata::default(),
        );
        ciphertext.ciphertext.move_to_device_of_server_key_if_set();
        Ok(ciphertext)
    }
}

impl FheTrivialEncrypt<bool> for FheBool {
    /// Creates a trivial encryption of a bool.
    ///
    /// # Warning
    ///
    /// Trivial encryptions are not real encryptions, as a trivially encrypted
    /// ciphertext can be decrypted by any key (in fact, no key is actually needed).
    ///
    /// Trivial encryptions become real encrypted data once used in an operation
    /// that involves a real ciphertext
    ///
    /// # Example
    ///
    /// ```rust
    /// use tfhe::prelude::*;
    /// use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};
    ///
    /// let (client_key, server_key) = generate_keys(ConfigBuilder::default());
    /// set_server_key(server_key);
    ///
    /// let a = FheBool::encrypt_trivial(true);
    ///
    /// let decrypted: bool = a.decrypt(&client_key);
    /// assert!(decrypted);
    /// ```
    #[track_caller]
    fn encrypt_trivial(value: bool) -> Self {
        Self::try_encrypt_trivial(value).unwrap()
    }
}

impl FheTryEncrypt<bool, CompressedPublicKey> for FheBool {
    type Error = crate::Error;

    fn try_encrypt(value: bool, key: &CompressedPublicKey) -> Result<Self, Self::Error> {
        let mut ciphertext = Self::new(
            key.key.encrypt_bool(value),
            key.tag.clone(),
            ReRandomizationMetadata::default(),
        );
        ciphertext.ciphertext.move_to_device_of_server_key_if_set();
        Ok(ciphertext)
    }
}

impl FheTryEncrypt<bool, PublicKey> for FheBool {
    type Error = crate::Error;

    fn try_encrypt(value: bool, key: &PublicKey) -> Result<Self, Self::Error> {
        let mut ciphertext = Self::new(
            key.key.encrypt_bool(value),
            key.tag.clone(),
            ReRandomizationMetadata::default(),
        );
        ciphertext.ciphertext.move_to_device_of_server_key_if_set();
        Ok(ciphertext)
    }
}

impl FheDecrypt<bool> for FheBool {
    /// Decrypts the value
    fn decrypt(&self, key: &ClientKey) -> bool {
        key.key.key.decrypt_bool(&self.ciphertext.on_cpu())
    }
}

impl FheTryTrivialEncrypt<bool> for FheBool {
    type Error = crate::Error;

    fn try_encrypt_trivial(value: bool) -> Result<Self, Self::Error> {
        let (ciphertext, tag) = global_state::with_internal_keys(|key| match key {
            InternalServerKey::Cpu(key) => {
                let ct = InnerBoolean::Cpu(key.pbs_key().create_trivial_boolean_block(value));
                (ct, key.tag.clone())
            }
            #[cfg(feature = "gpu")]
            InternalServerKey::Cuda(cuda_key) => {
                let streams = &cuda_key.streams;
                let inner: CudaUnsignedRadixCiphertext =
                    cuda_key
                        .key
                        .key
                        .create_trivial_radix(u64::from(value), 1, streams);
                let ct = InnerBoolean::Cuda(CudaBooleanBlock::from_cuda_radix_ciphertext(
                    inner.into_inner(),
                ));
                (ct, cuda_key.tag.clone())
            }
            #[cfg(feature = "hpu")]
            InternalServerKey::Hpu(_device) => {
                panic!("Hpu does not support trivial encryption")
            }
        });
        Ok(Self::new(
            ciphertext,
            tag,
            ReRandomizationMetadata::default(),
        ))
    }
}