GLWE

poulpy_core::layouts

Struct GLWE 

Source 
pub struct GLWE<D: Data> { /* private fields */ }

Implementations§

Source§

impl GLWE<Vec<u8>>

Source

pub fn automorphism_tmp_bytes<M, R, A, K, BE: Backend>( module: &M, res_infos: &R, a_infos: &A, key_infos: &K, ) -> usize
where R: GLWEInfos, A: GLWEInfos, K: GGLWEInfos, M: GLWEAutomorphism<BE>,

Source§

impl<DataSelf: DataMut> GLWE<DataSelf>

Source

pub fn automorphism<M, A, K, BE: Backend>( &mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>, )
where M: GLWEAutomorphism<BE>, A: GLWEToRef, K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn automorphism_add<M, A, K, BE: Backend>( &mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>, )
where M: GLWEAutomorphism<BE>, A: GLWEToRef, K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn automorphism_sub<M, A, K, BE: Backend>( &mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>, )
where M: GLWEAutomorphism<BE>, A: GLWEToRef, K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn automorphism_sub_negate<M, A, K, BE: Backend>( &mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>, )
where M: GLWEAutomorphism<BE>, A: GLWEToRef, K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn automorphism_inplace<M, K, BE: Backend>( &mut self, module: &M, key: &K, scratch: &mut Scratch<BE>, )
where M: GLWEAutomorphism<BE>, K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn automorphism_add_inplace<M, K, BE: Backend>( &mut self, module: &M, key: &K, scratch: &mut Scratch<BE>, )
where M: GLWEAutomorphism<BE>, K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn automorphism_sub_inplace<M, K, BE: Backend>( &mut self, module: &M, key: &K, scratch: &mut Scratch<BE>, )
where M: GLWEAutomorphism<BE>, K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn automorphism_sub_negate_inplace<M, K, BE: Backend>( &mut self, module: &M, key: &K, scratch: &mut Scratch<BE>, )
where M: GLWEAutomorphism<BE>, K: GetGaloisElement + GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source§

impl GLWE<Vec<u8>>

Source

pub fn from_lwe_tmp_bytes<R, A, K, M, BE: Backend>( module: &M, glwe_infos: &R, lwe_infos: &A, key_infos: &K, ) -> usize
where R: GLWEInfos, A: LWEInfos, K: GGLWEInfos, M: GLWEFromLWE<BE>,

Source§

impl<D: DataMut> GLWE<D>

Source

pub fn from_lwe<A, K, M, BE: Backend>( &mut self, module: &M, lwe: &A, ksk: &K, scratch: &mut Scratch<BE>, )
where M: GLWEFromLWE<BE>, A: LWEToRef, K: GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>,

Source§

impl GLWE<Vec<u8>>

Source

pub fn decrypt_tmp_bytes<A, M, BE: Backend>(module: &M, a_infos: &A) -> usize
where A: GLWEInfos, M: GLWEDecrypt<BE>,

Examples found in repository?
examples/encryption.rs (line 57)
15fn main() {
16    // Ring degree
17    let log_n: usize = 10;
18
19    let n: Degree = Degree(1 << log_n);
20
21    // Base-2-k (implicit digit decomposition)
22    let base2k: Base2K = Base2K(14);
23
24    // Ciphertext Torus precision (equivalent to ciphertext modulus)
25    let k_ct: TorusPrecision = TorusPrecision(27);
26
27    // Plaintext Torus precision (equivament to plaintext modulus)
28    let k_pt: TorusPrecision = TorusPrecision(base2k.into());
29
30    // GLWE rank
31    let rank: Rank = Rank(1);
32
33    // Instantiate Module (DFT Tables)
34    let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(n.0 as u64);
35
36    let glwe_ct_infos: GLWELayout = GLWELayout {
37        n,
38        base2k,
39        k: k_ct,
40        rank,
41    };
42
43    let glwe_pt_infos: GLWEPlaintextLayout = GLWEPlaintextLayout { n, base2k, k: k_pt };
44
45    // Allocates ciphertext & plaintexts
46    let mut ct: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_ct_infos);
47    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
48    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
49
50    // CPRNG
51    let mut source_xs: Source = Source::new([0u8; 32]);
52    let mut source_xe: Source = Source::new([1u8; 32]);
53    let mut source_xa: Source = Source::new([2u8; 32]);
54
55    // Scratch space
56    let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
57        GLWE::encrypt_sk_tmp_bytes(&module, &glwe_ct_infos) | GLWE::decrypt_tmp_bytes(&module, &glwe_ct_infos),
58    );
59
60    // Generate secret-key
61    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_ct_infos);
62    sk.fill_ternary_prob(0.5, &mut source_xs);
63
64    // Backend-prepared secret
65    let mut sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
66    sk_prepared.prepare(&module, &sk);
67
68    // Uniform plaintext
69    module.vec_znx_fill_uniform(base2k.into(), &mut pt_want.data, 0, &mut source_xa);
70
71    // Encryption
72    ct.encrypt_sk(
73        &module,
74        &pt_want,
75        &sk_prepared,
76        &mut source_xa,
77        &mut source_xe,
78        scratch.borrow(),
79    );
80
81    // Decryption
82    ct.decrypt(&module, &mut pt_have, &sk_prepared, scratch.borrow());
83
84    // Diff between pt - Dec(Enc(pt))
85    module.glwe_sub_inplace(&mut pt_want, &pt_have);
86
87    // Ideal vs. actual noise
88    let noise_have: f64 = pt_want.data.std(base2k.into(), 0) * (ct.k().as_u32() as f64).exp2();
89    let noise_want: f64 = SIGMA;
90
91    // Check
92    assert!(noise_have <= noise_want + 0.2);
93}
Source§

impl<DataSelf: DataRef> GLWE<DataSelf>

Source

pub fn decrypt<P, S, M, BE: Backend>( &self, module: &M, pt: &mut P, sk: &S, scratch: &mut Scratch<BE>, )
where P: GLWEPlaintextToMut, S: GLWESecretPreparedToRef<BE>, M: GLWEDecrypt<BE>, Scratch<BE>: ScratchTakeBasic,

Examples found in repository?
examples/encryption.rs (line 82)
15fn main() {
16    // Ring degree
17    let log_n: usize = 10;
18
19    let n: Degree = Degree(1 << log_n);
20
21    // Base-2-k (implicit digit decomposition)
22    let base2k: Base2K = Base2K(14);
23
24    // Ciphertext Torus precision (equivalent to ciphertext modulus)
25    let k_ct: TorusPrecision = TorusPrecision(27);
26
27    // Plaintext Torus precision (equivament to plaintext modulus)
28    let k_pt: TorusPrecision = TorusPrecision(base2k.into());
29
30    // GLWE rank
31    let rank: Rank = Rank(1);
32
33    // Instantiate Module (DFT Tables)
34    let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(n.0 as u64);
35
36    let glwe_ct_infos: GLWELayout = GLWELayout {
37        n,
38        base2k,
39        k: k_ct,
40        rank,
41    };
42
43    let glwe_pt_infos: GLWEPlaintextLayout = GLWEPlaintextLayout { n, base2k, k: k_pt };
44
45    // Allocates ciphertext & plaintexts
46    let mut ct: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_ct_infos);
47    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
48    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
49
50    // CPRNG
51    let mut source_xs: Source = Source::new([0u8; 32]);
52    let mut source_xe: Source = Source::new([1u8; 32]);
53    let mut source_xa: Source = Source::new([2u8; 32]);
54
55    // Scratch space
56    let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
57        GLWE::encrypt_sk_tmp_bytes(&module, &glwe_ct_infos) | GLWE::decrypt_tmp_bytes(&module, &glwe_ct_infos),
58    );
59
60    // Generate secret-key
61    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_ct_infos);
62    sk.fill_ternary_prob(0.5, &mut source_xs);
63
64    // Backend-prepared secret
65    let mut sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
66    sk_prepared.prepare(&module, &sk);
67
68    // Uniform plaintext
69    module.vec_znx_fill_uniform(base2k.into(), &mut pt_want.data, 0, &mut source_xa);
70
71    // Encryption
72    ct.encrypt_sk(
73        &module,
74        &pt_want,
75        &sk_prepared,
76        &mut source_xa,
77        &mut source_xe,
78        scratch.borrow(),
79    );
80
81    // Decryption
82    ct.decrypt(&module, &mut pt_have, &sk_prepared, scratch.borrow());
83
84    // Diff between pt - Dec(Enc(pt))
85    module.glwe_sub_inplace(&mut pt_want, &pt_have);
86
87    // Ideal vs. actual noise
88    let noise_have: f64 = pt_want.data.std(base2k.into(), 0) * (ct.k().as_u32() as f64).exp2();
89    let noise_want: f64 = SIGMA;
90
91    // Check
92    assert!(noise_have <= noise_want + 0.2);
93}
Source§

impl GLWE<Vec<u8>>

Source

pub fn encrypt_sk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
where A: GLWEInfos, M: GLWEEncryptSk<BE>,

Examples found in repository?
examples/encryption.rs (line 57)
15fn main() {
16    // Ring degree
17    let log_n: usize = 10;
18
19    let n: Degree = Degree(1 << log_n);
20
21    // Base-2-k (implicit digit decomposition)
22    let base2k: Base2K = Base2K(14);
23
24    // Ciphertext Torus precision (equivalent to ciphertext modulus)
25    let k_ct: TorusPrecision = TorusPrecision(27);
26
27    // Plaintext Torus precision (equivament to plaintext modulus)
28    let k_pt: TorusPrecision = TorusPrecision(base2k.into());
29
30    // GLWE rank
31    let rank: Rank = Rank(1);
32
33    // Instantiate Module (DFT Tables)
34    let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(n.0 as u64);
35
36    let glwe_ct_infos: GLWELayout = GLWELayout {
37        n,
38        base2k,
39        k: k_ct,
40        rank,
41    };
42
43    let glwe_pt_infos: GLWEPlaintextLayout = GLWEPlaintextLayout { n, base2k, k: k_pt };
44
45    // Allocates ciphertext & plaintexts
46    let mut ct: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_ct_infos);
47    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
48    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
49
50    // CPRNG
51    let mut source_xs: Source = Source::new([0u8; 32]);
52    let mut source_xe: Source = Source::new([1u8; 32]);
53    let mut source_xa: Source = Source::new([2u8; 32]);
54
55    // Scratch space
56    let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
57        GLWE::encrypt_sk_tmp_bytes(&module, &glwe_ct_infos) | GLWE::decrypt_tmp_bytes(&module, &glwe_ct_infos),
58    );
59
60    // Generate secret-key
61    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_ct_infos);
62    sk.fill_ternary_prob(0.5, &mut source_xs);
63
64    // Backend-prepared secret
65    let mut sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
66    sk_prepared.prepare(&module, &sk);
67
68    // Uniform plaintext
69    module.vec_znx_fill_uniform(base2k.into(), &mut pt_want.data, 0, &mut source_xa);
70
71    // Encryption
72    ct.encrypt_sk(
73        &module,
74        &pt_want,
75        &sk_prepared,
76        &mut source_xa,
77        &mut source_xe,
78        scratch.borrow(),
79    );
80
81    // Decryption
82    ct.decrypt(&module, &mut pt_have, &sk_prepared, scratch.borrow());
83
84    // Diff between pt - Dec(Enc(pt))
85    module.glwe_sub_inplace(&mut pt_want, &pt_have);
86
87    // Ideal vs. actual noise
88    let noise_have: f64 = pt_want.data.std(base2k.into(), 0) * (ct.k().as_u32() as f64).exp2();
89    let noise_want: f64 = SIGMA;
90
91    // Check
92    assert!(noise_have <= noise_want + 0.2);
93}
Source

pub fn encrypt_pk_tmp_bytes<M, A, BE: Backend>(module: &M, infos: &A) -> usize
where A: GLWEInfos, M: GLWEEncryptPk<BE>,

Source§

impl<D: DataMut> GLWE<D>

Source

pub fn encrypt_sk<P, S, M, BE: Backend>( &mut self, module: &M, pt: &P, sk: &S, source_xa: &mut Source, source_xe: &mut Source, scratch: &mut Scratch<BE>, )
where P: GLWEPlaintextToRef, S: GLWESecretPreparedToRef<BE>, M: GLWEEncryptSk<BE>, Scratch<BE>: ScratchTakeCore<BE>,

Examples found in repository?
examples/encryption.rs (lines 72-79)
15fn main() {
16    // Ring degree
17    let log_n: usize = 10;
18
19    let n: Degree = Degree(1 << log_n);
20
21    // Base-2-k (implicit digit decomposition)
22    let base2k: Base2K = Base2K(14);
23
24    // Ciphertext Torus precision (equivalent to ciphertext modulus)
25    let k_ct: TorusPrecision = TorusPrecision(27);
26
27    // Plaintext Torus precision (equivament to plaintext modulus)
28    let k_pt: TorusPrecision = TorusPrecision(base2k.into());
29
30    // GLWE rank
31    let rank: Rank = Rank(1);
32
33    // Instantiate Module (DFT Tables)
34    let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(n.0 as u64);
35
36    let glwe_ct_infos: GLWELayout = GLWELayout {
37        n,
38        base2k,
39        k: k_ct,
40        rank,
41    };
42
43    let glwe_pt_infos: GLWEPlaintextLayout = GLWEPlaintextLayout { n, base2k, k: k_pt };
44
45    // Allocates ciphertext & plaintexts
46    let mut ct: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_ct_infos);
47    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
48    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
49
50    // CPRNG
51    let mut source_xs: Source = Source::new([0u8; 32]);
52    let mut source_xe: Source = Source::new([1u8; 32]);
53    let mut source_xa: Source = Source::new([2u8; 32]);
54
55    // Scratch space
56    let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
57        GLWE::encrypt_sk_tmp_bytes(&module, &glwe_ct_infos) | GLWE::decrypt_tmp_bytes(&module, &glwe_ct_infos),
58    );
59
60    // Generate secret-key
61    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_ct_infos);
62    sk.fill_ternary_prob(0.5, &mut source_xs);
63
64    // Backend-prepared secret
65    let mut sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
66    sk_prepared.prepare(&module, &sk);
67
68    // Uniform plaintext
69    module.vec_znx_fill_uniform(base2k.into(), &mut pt_want.data, 0, &mut source_xa);
70
71    // Encryption
72    ct.encrypt_sk(
73        &module,
74        &pt_want,
75        &sk_prepared,
76        &mut source_xa,
77        &mut source_xe,
78        scratch.borrow(),
79    );
80
81    // Decryption
82    ct.decrypt(&module, &mut pt_have, &sk_prepared, scratch.borrow());
83
84    // Diff between pt - Dec(Enc(pt))
85    module.glwe_sub_inplace(&mut pt_want, &pt_have);
86
87    // Ideal vs. actual noise
88    let noise_have: f64 = pt_want.data.std(base2k.into(), 0) * (ct.k().as_u32() as f64).exp2();
89    let noise_want: f64 = SIGMA;
90
91    // Check
92    assert!(noise_have <= noise_want + 0.2);
93}
Source

pub fn encrypt_zero_sk<S, M, BE: Backend>( &mut self, module: &M, sk: &S, source_xa: &mut Source, source_xe: &mut Source, scratch: &mut Scratch<BE>, )
where S: GLWESecretPreparedToRef<BE>, M: GLWEEncryptSk<BE>, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn encrypt_pk<P, K, M, BE: Backend>( &mut self, module: &M, pt: &P, pk: &K, source_xu: &mut Source, source_xe: &mut Source, scratch: &mut Scratch<BE>, )
where P: GLWEPlaintextToRef + GLWEInfos, K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos, M: GLWEEncryptPk<BE>,

Source

pub fn encrypt_zero_pk<K, M, BE: Backend>( &mut self, module: &M, pk: &K, source_xu: &mut Source, source_xe: &mut Source, scratch: &mut Scratch<BE>, )
where K: GLWEPreparedToRef<BE> + GetDistribution + GLWEInfos, M: GLWEEncryptPk<BE>,

Source§

impl GLWE<Vec<u8>>

Source

pub fn external_product_tmp_bytes<R, A, B, M, BE: Backend>( module: &M, res_infos: &R, a_infos: &A, b_infos: &B, ) -> usize
where R: GLWEInfos, A: GLWEInfos, B: GGSWInfos, M: GLWEExternalProduct<BE>,

Source§

impl<DataSelf: DataMut> GLWE<DataSelf>

Source

pub fn external_product<A, B, M, BE: Backend>( &mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>, )
where A: GLWEToRef, B: GGSWPreparedToRef<BE>, M: GLWEExternalProduct<BE>, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn external_product_inplace<A, M, BE: Backend>( &mut self, module: &M, a: &A, scratch: &mut Scratch<BE>, )
where A: GGSWPreparedToRef<BE>, M: GLWEExternalProduct<BE>, Scratch<BE>: ScratchTakeCore<BE>,

Source§

impl GLWE<Vec<u8>>

Source

pub fn trace_galois_elements<M, BE: Backend>(module: &M) -> Vec<i64>
where M: GLWETrace<BE>,

Source

pub fn trace_tmp_bytes<R, A, K, M, BE: Backend>( module: &M, res_infos: &R, a_infos: &A, key_infos: &K, ) -> usize
where R: GLWEInfos, A: GLWEInfos, K: GGLWEInfos, M: GLWETrace<BE>,

Source§

impl<D: DataMut> GLWE<D>

Source

pub fn trace<A, K, M, BE: Backend>( &mut self, module: &M, start: usize, end: usize, a: &A, keys: &HashMap<i64, K>, scratch: &mut Scratch<BE>, )
where A: GLWEToRef, K: GGLWEPreparedToRef<BE> + GetGaloisElement + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>, M: GLWETrace<BE>,

Source

pub fn trace_inplace<K, M, BE: Backend>( &mut self, module: &M, start: usize, end: usize, keys: &HashMap<i64, K>, scratch: &mut Scratch<BE>, )
where K: GGLWEPreparedToRef<BE> + GetGaloisElement + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>, M: GLWETrace<BE>,

Source§

impl GLWE<Vec<u8>>

Source

pub fn keyswitch_tmp_bytes<M, R, A, B, BE: Backend>( module: &M, res_infos: &R, a_infos: &A, key_infos: &B, ) -> usize
where R: GLWEInfos, A: GLWEInfos, B: GGLWEInfos, M: GLWEKeyswitch<BE>,

Source§

impl<D: DataMut> GLWE<D>

Source

pub fn keyswitch<A, B, M, BE: Backend>( &mut self, module: &M, a: &A, b: &B, scratch: &mut Scratch<BE>, )
where A: GLWEToRef, B: GGLWEPreparedToRef<BE>, M: GLWEKeyswitch<BE>, Scratch<BE>: ScratchTakeCore<BE>,

Source

pub fn keyswitch_inplace<A, M, BE: Backend>( &mut self, module: &M, a: &A, scratch: &mut Scratch<BE>, )
where A: GGLWEPreparedToRef<BE>, M: GLWEKeyswitch<BE>, Scratch<BE>: ScratchTakeCore<BE>,

Source§

impl<D: DataRef> GLWE<D>

Source

pub fn noise<M, S, P, BE: Backend>( &self, module: &M, sk_prepared: &S, pt_want: &P, scratch: &mut Scratch<BE>, ) -> f64
where M: GLWENoise<BE>, S: GLWESecretPreparedToRef<BE>, P: GLWEPlaintextToRef,

Source

pub fn assert_noise<M, BE: Backend, S, P>( &self, module: &M, sk_prepared: &S, pt_want: &P, max_noise: f64, )
where S: GLWESecretPreparedToRef<BE>, P: GLWEPlaintextToRef, M: GLWENoise<BE>,

Source§

impl GLWE<Vec<u8>>

Source

pub fn rsh_tmp_bytes<M, BE: Backend>(module: &M) -> usize
where M: GLWEShift<BE>,

Source§

impl<D: DataRef> GLWE<D>

Source

pub fn data(&self) -> &VecZnx<D>

Source§

impl<D: DataMut> GLWE<D>

Source

pub fn data_mut(&mut self) -> &mut VecZnx<D>

Source§

impl GLWE<Vec<u8>>

Source

pub fn alloc_from_infos<A>(infos: &A) -> Self
where A: GLWEInfos,

Examples found in repository?
examples/encryption.rs (line 46)
15fn main() {
16    // Ring degree
17    let log_n: usize = 10;
18
19    let n: Degree = Degree(1 << log_n);
20
21    // Base-2-k (implicit digit decomposition)
22    let base2k: Base2K = Base2K(14);
23
24    // Ciphertext Torus precision (equivalent to ciphertext modulus)
25    let k_ct: TorusPrecision = TorusPrecision(27);
26
27    // Plaintext Torus precision (equivament to plaintext modulus)
28    let k_pt: TorusPrecision = TorusPrecision(base2k.into());
29
30    // GLWE rank
31    let rank: Rank = Rank(1);
32
33    // Instantiate Module (DFT Tables)
34    let module: Module<FFT64Spqlios> = Module::<FFT64Spqlios>::new(n.0 as u64);
35
36    let glwe_ct_infos: GLWELayout = GLWELayout {
37        n,
38        base2k,
39        k: k_ct,
40        rank,
41    };
42
43    let glwe_pt_infos: GLWEPlaintextLayout = GLWEPlaintextLayout { n, base2k, k: k_pt };
44
45    // Allocates ciphertext & plaintexts
46    let mut ct: GLWE<Vec<u8>> = GLWE::alloc_from_infos(&glwe_ct_infos);
47    let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
48    let mut pt_have: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc_from_infos(&glwe_pt_infos);
49
50    // CPRNG
51    let mut source_xs: Source = Source::new([0u8; 32]);
52    let mut source_xe: Source = Source::new([1u8; 32]);
53    let mut source_xa: Source = Source::new([2u8; 32]);
54
55    // Scratch space
56    let mut scratch: ScratchOwned<FFT64Spqlios> = ScratchOwned::alloc(
57        GLWE::encrypt_sk_tmp_bytes(&module, &glwe_ct_infos) | GLWE::decrypt_tmp_bytes(&module, &glwe_ct_infos),
58    );
59
60    // Generate secret-key
61    let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&glwe_ct_infos);
62    sk.fill_ternary_prob(0.5, &mut source_xs);
63
64    // Backend-prepared secret
65    let mut sk_prepared: GLWESecretPrepared<Vec<u8>, FFT64Spqlios> = GLWESecretPrepared::alloc(&module, rank);
66    sk_prepared.prepare(&module, &sk);
67
68    // Uniform plaintext
69    module.vec_znx_fill_uniform(base2k.into(), &mut pt_want.data, 0, &mut source_xa);
70
71    // Encryption
72    ct.encrypt_sk(
73        &module,
74        &pt_want,
75        &sk_prepared,
76        &mut source_xa,
77        &mut source_xe,
78        scratch.borrow(),
79    );
80
81    // Decryption
82    ct.decrypt(&module, &mut pt_have, &sk_prepared, scratch.borrow());
83
84    // Diff between pt - Dec(Enc(pt))
85    module.glwe_sub_inplace(&mut pt_want, &pt_have);
86
87    // Ideal vs. actual noise
88    let noise_have: f64 = pt_want.data.std(base2k.into(), 0) * (ct.k().as_u32() as f64).exp2();
89    let noise_want: f64 = SIGMA;
90
91    // Check
92    assert!(noise_have <= noise_want + 0.2);
93}
Source

pub fn alloc(n: Degree, base2k: Base2K, k: TorusPrecision, rank: Rank) -> Self

Source

pub fn bytes_of_from_infos<A>(infos: &A) -> usize
where A: GLWEInfos,

Source

pub fn bytes_of( n: Degree, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> usize

Source§

impl<D: DataMut> GLWE<D>

Source

pub fn decompress<O, M>(&mut self, module: &M, other: &O)
where O: GLWECompressedToRef + GLWEInfos, M: GLWEDecompress,

Trait Implementations§

Source§

impl<D: Clone + Data> Clone for GLWE<D>

Source§

fn clone(&self) -> GLWE<D>

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl<D: DataRef> Debug for GLWE<D>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl<D: DataRef> Display for GLWE<D>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl<D: DataMut> FillUniform for GLWE<D>

Source§

fn fill_uniform(&mut self, log_bound: usize, source: &mut Source)

Source§

impl<D: Data> GLWEInfos for GLWE<D>

Source§

fn rank(&self) -> Rank

Source§

fn glwe_layout(&self) -> GLWELayout

Source§

impl<D: DataMut> GLWEToMut for GLWE<D>

Source§

fn to_mut(&mut self) -> GLWE<&mut [u8]>

Source§

impl<D: DataRef> GLWEToRef for GLWE<D>

Source§

fn to_ref(&self) -> GLWE<&[u8]>

Source§

impl<D: Data> LWEInfos for GLWE<D>

Source§

fn base2k(&self) -> Base2K

Source§

fn k(&self) -> TorusPrecision

Source§

fn n(&self) -> Degree

Source§

fn size(&self) -> usize

Source§

fn log_n(&self) -> usize

Source§

fn max_k(&self) -> TorusPrecision

Source§

fn lwe_layout(&self) -> LWELayout

Source§

impl<D: PartialEq + Data> PartialEq for GLWE<D>

Source§

fn eq(&self, other: &GLWE<D>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl<D: DataMut> ReaderFrom for GLWE<D>

Source§

fn read_from<R: Read>(&mut self, reader: &mut R) -> Result<()>

Source§

impl<D: DataMut> SetGLWEInfos for GLWE<D>

Source§

fn set_base2k(&mut self, base2k: Base2K)

Source§

fn set_k(&mut self, k: TorusPrecision)

Source§

impl<D: DataRef> ToOwnedDeep for GLWE<D>

Source§

type Owned = GLWE<Vec<u8>>

Source§

fn to_owned_deep(&self) -> Self::Owned

Source§

impl<D: DataRef> WriterTo for GLWE<D>

Source§

fn write_to<W: Write>(&self, writer: &mut W) -> Result<()>

Source§

impl<D: Eq + Data> Eq for GLWE<D>

Source§

impl<D: Data> StructuralPartialEq for GLWE<D>

Auto Trait Implementations§

§

impl<D> Freeze for GLWE<D>
where D: Freeze,

§

impl<D> RefUnwindSafe for GLWE<D>
where D: RefUnwindSafe,

§

impl<D> Send for GLWE<D>
where D: Send,

§

impl<D> Sync for GLWE<D>
where D: Sync,

§

impl<D> Unpin for GLWE<D>
where D: Unpin,

§

impl<D> UnwindSafe for GLWE<D>
where D: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Az for T

Source§

fn az<Dst>(self) -> Dst
where T: Cast<Dst>,

Casts the value.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<Src, Dst> CastFrom<Src> for Dst
where Src: Cast<Dst>,

Source§

fn cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> CheckedAs for T

Source§

fn checked_as<Dst>(self) -> Option<Dst>
where T: CheckedCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> CheckedCastFrom<Src> for Dst
where Src: CheckedCast<Dst>,

Source§

fn checked_cast_from(src: Src) -> Option<Dst>

Casts the value.
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> OverflowingAs for T

Source§

fn overflowing_as<Dst>(self) -> (Dst, bool)
where T: OverflowingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> OverflowingCastFrom<Src> for Dst
where Src: OverflowingCast<Dst>,

Source§

fn overflowing_cast_from(src: Src) -> (Dst, bool)

Casts the value.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> SaturatingAs for T

Source§

fn saturating_as<Dst>(self) -> Dst
where T: SaturatingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> SaturatingCastFrom<Src> for Dst
where Src: SaturatingCast<Dst>,

Source§

fn saturating_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> UnwrappedAs for T

Source§

fn unwrapped_as<Dst>(self) -> Dst
where T: UnwrappedCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> UnwrappedCastFrom<Src> for Dst
where Src: UnwrappedCast<Dst>,

Source§

fn unwrapped_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WrappingAs for T

Source§

fn wrapping_as<Dst>(self) -> Dst
where T: WrappingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> WrappingCastFrom<Src> for Dst
where Src: WrappingCast<Dst>,

Source§

fn wrapping_cast_from(src: Src) -> Dst

Casts the value.