poulpy-core 0.5.0

A backend agnostic crate implementing RLWE-based encryption & arithmetic.
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

use poulpy_hal::{
    api::{ScratchAvailable, ScratchTakeBasic, SvpPPolBytesOf},
    layouts::{Backend, DataMut, DataRef, Module, Scratch, ZnxView, ZnxViewMut},
};

use crate::{
    GLWEDecrypt, ScratchTakeCore,
    layouts::{
        GLWEInfos, GLWEPlaintext, GLWESecretPrepared, GLWESecretTensor, GLWESecretTensorPrepared, GLWETensor,
        prepared::GLWESecretPreparedFactory,
    },
};

impl GLWETensor<Vec<u8>> {
    pub fn decrypt_tmp_bytes<A, M, BE: Backend>(module: &M, a_infos: &A) -> usize
    where
        A: GLWEInfos,
        M: GLWETensorDecrypt<BE>,
    {
        module.glwe_tensor_decrypt_tmp_bytes(a_infos)
    }
}

impl<DataSelf: DataRef> GLWETensor<DataSelf> {
    pub fn decrypt<P, S0, S1, M, BE: Backend>(
        &self,
        module: &M,
        pt: &mut GLWEPlaintext<P>,
        sk: &GLWESecretPrepared<S0, BE>,
        sk_tensor: &GLWESecretTensorPrepared<S1, BE>,
        scratch: &mut Scratch<BE>,
    ) where
        P: DataMut,
        S0: DataRef,
        S1: DataRef,
        M: GLWETensorDecrypt<BE>,
        Scratch<BE>: ScratchTakeBasic,
    {
        module.glwe_tensor_decrypt(self, pt, sk, sk_tensor, scratch);
    }
}

pub trait GLWETensorDecrypt<BE: Backend> {
    fn glwe_tensor_decrypt_tmp_bytes<A>(&self, infos: &A) -> usize
    where
        A: GLWEInfos;
    fn glwe_tensor_decrypt<R, P, S0, S1>(
        &self,
        res: &GLWETensor<R>,
        pt: &mut GLWEPlaintext<P>,
        sk: &GLWESecretPrepared<S0, BE>,
        sk_tensor: &GLWESecretTensorPrepared<S1, BE>,
        scratch: &mut Scratch<BE>,
    ) where
        R: DataRef,
        P: DataMut,
        S0: DataRef,
        S1: DataRef;
}

impl<BE: Backend> GLWETensorDecrypt<BE> for Module<BE>
where
    Self: GLWEDecrypt<BE> + SvpPPolBytesOf + GLWESecretPreparedFactory<BE>,
    Scratch<BE>: ScratchTakeCore<BE>,
{
    fn glwe_tensor_decrypt_tmp_bytes<A>(&self, infos: &A) -> usize
    where
        A: GLWEInfos,
    {
        assert_eq!(self.n() as u32, infos.n());

        let rank: usize = infos.rank().into();
        let lvl_0: usize = self.bytes_of_glwe_secret_prepared((GLWESecretTensor::pairs(rank) + rank).into());
        let lvl_1: usize = self.glwe_decrypt_tmp_bytes(infos);

        lvl_0 + lvl_1
    }

    fn glwe_tensor_decrypt<R, P, S0, S1>(
        &self,
        res: &GLWETensor<R>,
        pt: &mut GLWEPlaintext<P>,
        sk: &GLWESecretPrepared<S0, BE>,
        sk_tensor: &GLWESecretTensorPrepared<S1, BE>,
        scratch: &mut Scratch<BE>,
    ) where
        R: DataRef,
        P: DataMut,
        S0: DataRef,
        S1: DataRef,
    {
        assert!(
            scratch.available() >= self.glwe_tensor_decrypt_tmp_bytes(res),
            "scratch.available(): {} < GLWETensorDecrypt::glwe_tensor_decrypt_tmp_bytes: {}",
            scratch.available(),
            self.glwe_tensor_decrypt_tmp_bytes(res)
        );

        let rank: usize = sk.rank().as_usize();

        let (mut sk_grouped, scratch_1) = scratch.take_glwe_secret_prepared(self, (GLWESecretTensor::pairs(rank) + rank).into());

        for i in 0..rank {
            sk_grouped.data.at_mut(i, 0).copy_from_slice(sk.data.at(i, 0));
        }

        for i in 0..sk_grouped.rank().as_usize() - rank {
            sk_grouped.data.at_mut(i + rank, 0).copy_from_slice(sk_tensor.data.at(i, 0));
        }

        self.glwe_decrypt(res, pt, &sk_grouped, scratch_1);
    }
}