1use poulpy_hal::{
  2    api::{ScratchOwnedAlloc, ScratchOwnedBorrow},
  3    layouts::{Backend, Module, ScalarZnx, Scratch, ScratchOwned},
  4    source::Source,
  5};
  6
  7use crate::{
  8    GGSWCompressedEncryptSk, GGSWEncryptSk, GGSWNoise, ScratchTakeCore,
  9    encryption::SIGMA,
 10    layouts::{
 11        GGSW, GGSWDecompress, GGSWLayout, GLWESecret, GLWESecretPrepare, GLWESecretPreparedAlloc, compressed::GGSWCompressed,
 12        prepared::GLWESecretPrepared,
 13    },
 14};
 15
 16pub fn test_ggsw_encrypt_sk<BE: Backend>(module: &Module<BE>)
 17where
 18    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
 19    Scratch<BE>: ScratchTakeCore<BE>,
 20    Module<BE>: GGSWEncryptSk<BE> + GLWESecretPreparedAlloc<BE> + GLWESecretPrepare<BE> + GGSWNoise<BE>,
 21{
 22    let base2k: usize = 12;
 23    let k: usize = 54;
 24    let dsize: usize = k / base2k;
 25    for rank in 1_usize..3 {
 26        for di in 1..dsize + 1 {
 27            let n: usize = module.n();
 28            let dnum: usize = (k - di * base2k) / (di * base2k);
 29
 30            let ggsw_infos: GGSWLayout = GGSWLayout {
 31                n: n.into(),
 32                base2k: base2k.into(),
 33                k: k.into(),
 34                dnum: dnum.into(),
 35                dsize: di.into(),
 36                rank: rank.into(),
 37            };
 38
 39            let mut ct: GGSW<Vec<u8>> = GGSW::alloc_from_infos(&ggsw_infos);
 40
 41            let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
 42
 43            let mut source_xs: Source = Source::new([0u8; 32]);
 44            let mut source_xe: Source = Source::new([0u8; 32]);
 45            let mut source_xa: Source = Source::new([0u8; 32]);
 46
 47            pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
 48
 49            let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(GGSW::encrypt_sk_tmp_bytes(module, &ggsw_infos));
 50
 51            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&ggsw_infos);
 52            sk.fill_ternary_prob(0.5, &mut source_xs);
 53
 54            let mut sk_prepared: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc(module, rank.into());
 55            sk_prepared.prepare(module, &sk);
 56
 57            ct.encrypt_sk(
 58                module,
 59                &pt_scalar,
 60                &sk_prepared,
 61                &mut source_xa,
 62                &mut source_xe,
 63                scratch.borrow(),
 64            );
 65
 66            let noise_f = |_col_i: usize| -(k as f64) + SIGMA.log2() + 0.5;
 67
 68            ct.assert_noise(module, &sk_prepared, &pt_scalar, noise_f);
 69        }
 70    }
 71}
 72
 73pub fn test_ggsw_compressed_encrypt_sk<BE: Backend>(module: &Module<BE>)
 74where
 75    ScratchOwned<BE>: ScratchOwnedAlloc<BE> + ScratchOwnedBorrow<BE>,
 76    Scratch<BE>: ScratchTakeCore<BE>,
 77    Module<BE>:
 78        GGSWCompressedEncryptSk<BE> + GLWESecretPreparedAlloc<BE> + GLWESecretPrepare<BE> + GGSWNoise<BE> + GGSWDecompress,
 79{
 80    let base2k: usize = 12;
 81    let k: usize = 54;
 82    let dsize: usize = k / base2k;
 83    for rank in 1_usize..3 {
 84        for di in 1..dsize + 1 {
 85            let n: usize = module.n();
 86            let dnum: usize = (k - di * base2k) / (di * base2k);
 87
 88            let ggsw_infos: GGSWLayout = GGSWLayout {
 89                n: n.into(),
 90                base2k: base2k.into(),
 91                k: k.into(),
 92                dnum: dnum.into(),
 93                dsize: di.into(),
 94                rank: rank.into(),
 95            };
 96
 97            let mut ct_compressed: GGSWCompressed<Vec<u8>> = GGSWCompressed::alloc_from_infos(&ggsw_infos);
 98
 99            let mut pt_scalar: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
100
101            let mut source_xs: Source = Source::new([0u8; 32]);
102            let mut source_xe: Source = Source::new([0u8; 32]);
103
104            pt_scalar.fill_ternary_hw(0, n, &mut source_xs);
105
106            let mut scratch: ScratchOwned<BE> = ScratchOwned::alloc(GGSWCompressed::encrypt_sk_tmp_bytes(module, &ggsw_infos));
107
108            let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc_from_infos(&ggsw_infos);
109            sk.fill_ternary_prob(0.5, &mut source_xs);
110
111            let mut sk_prepared: GLWESecretPrepared<Vec<u8>, BE> = GLWESecretPrepared::alloc(module, rank.into());
112            sk_prepared.prepare(module, &sk);
113
114            let seed_xa: [u8; 32] = [1u8; 32];
115
116            ct_compressed.encrypt_sk(
117                module,
118                &pt_scalar,
119                &sk_prepared,
120                seed_xa,
121                &mut source_xe,
122                scratch.borrow(),
123            );
124
125            let noise_f = |_col_i: usize| -(k as f64) + SIGMA.log2() + 0.5;
126
127            let mut ct: GGSW<Vec<u8>> = GGSW::alloc_from_infos(&ggsw_infos);
128            ct.decompress(module, &ct_compressed);
129
130            ct.assert_noise(module, &sk_prepared, &pt_scalar, noise_f);
131        }
132    }
133}