chore(backward): add data for the new zk proof

utils/tfhe-backward-compat-data/crates/generate_1_5/src/lib.rs

@@ -7,7 +7,11 @@ use tfhe::boolean::engine::BooleanEngine;
 use tfhe::core_crypto::commons::generators::DeterministicSeeder;
 use tfhe::core_crypto::prelude::DefaultRandomGenerator;
 use tfhe::shortint::engine::ShortintEngine;
-use tfhe::{CompressedServerKey, Seed};
+use tfhe::zk::{CompactPkeCrs, ZkComputeLoad};
+use tfhe::{
+    ClientKey, CompactPublicKey, CompressedServerKey, ProvenCompactCiphertextList, Seed, ServerKey,
+    set_server_key,
+};
 use tfhe_backward_compat_data::generate::*;
 use tfhe_backward_compat_data::*;
 use utils::*;
@@ -30,6 +34,23 @@ const HL_SERVERKEY_WITH_COMPRESSION_TEST: HlServerKeyTest = HlServerKeyTest {
     rerand_cpk_filename: None,
     compressed: false,
 };
+
+// We have a proven list generated for 0.11, but since this version the hash modes have evolved so
+// we re generate one
+const HL_PROVEN_COMPACTLIST_TEST_ZKV2: HlHeterogeneousCiphertextListTest =
+    HlHeterogeneousCiphertextListTest {
+        test_filename: Cow::Borrowed("hl_proven_list_zkv2_1_5"),
+        key_filename: Cow::Borrowed("client_key_for_zk"),
+        clear_values: Cow::Borrowed(&[17u8 as u64]),
+        data_kinds: Cow::Borrowed(&[DataKind::Unsigned]),
+        compressed: false,
+        proof_info: Some(PkeZkProofAuxiliaryInfo {
+            public_key_filename: Cow::Borrowed("public_key"),
+            params_filename: Cow::Borrowed("zk_pke_crs"),
+            metadata: Cow::Borrowed("2vdrawkcab"),
+        }),
+    };
+
 pub struct V1_5;
 
 impl TfhersVersion for V1_5 {
@@ -54,29 +75,97 @@ impl TfhersVersion for V1_5 {
         let dir = Self::data_dir(base_data_dir).join(HL_MODULE_NAME);
         create_dir_all(&dir).unwrap();
 
-        let config =
+        {
-            tfhe::ConfigBuilder::with_custom_parameters(HL_CLIENTKEY_TEST.parameters.convert())
+            let config =
-                .enable_compression(INSECURE_TEST_PARAMS_TUNIFORM_COMPRESSION_MULTIBIT.convert())
+                tfhe::ConfigBuilder::with_custom_parameters(HL_CLIENTKEY_TEST.parameters.convert())
-                .build();
+                    .enable_compression(
-        let (hl_client_key, hl_server_key) = tfhe::generate_keys(config);
+                        INSECURE_TEST_PARAMS_TUNIFORM_COMPRESSION_MULTIBIT.convert(),
-        let compressed_server_key = CompressedServerKey::new(&hl_client_key);
+                    )
+                    .build();
+            let (hl_client_key, hl_server_key) = tfhe::generate_keys(config);
+            let compressed_server_key = CompressedServerKey::new(&hl_client_key);
 
-        store_versioned_test(&hl_client_key, &dir, &HL_CLIENTKEY_TEST.test_filename);
+            store_versioned_test(&hl_client_key, &dir, &HL_CLIENTKEY_TEST.test_filename);
-        store_versioned_test(
+            store_versioned_test(
-            &compressed_server_key,
+                &compressed_server_key,
-            &dir,
+                &dir,
-            &HL_COMPRESSED_SERVERKEY_TEST.test_filename,
+                &HL_COMPRESSED_SERVERKEY_TEST.test_filename,
-        );
+            );
-        store_versioned_test(
+            store_versioned_test(
-            &hl_server_key,
+                &hl_server_key,
-            &dir,
+                &dir,
-            &HL_SERVERKEY_WITH_COMPRESSION_TEST.test_filename,
+                &HL_SERVERKEY_WITH_COMPRESSION_TEST.test_filename,
-        );
+            );
+        }
+
+        // Generate a zk proof with the new hash modes
+        {
+            let config = tfhe::ConfigBuilder::with_custom_parameters(
+                INSECURE_SMALL_TEST_PARAMS_KS32.convert(),
+            )
+            .use_dedicated_compact_public_key_parameters((
+                INSECURE_DEDICATED_CPK_TEST_PARAMS.convert(),
+                KS_TO_SMALL_TEST_PARAMS.convert(),
+            ))
+            .build();
+            let hl_client_key = ClientKey::generate(config);
+            let hl_server_key = ServerKey::new(&hl_client_key);
+            set_server_key(hl_server_key.clone());
+            let compact_pub_key = CompactPublicKey::new(&hl_client_key);
+            let crs = CompactPkeCrs::from_config(config, 64).unwrap();
+
+            store_versioned_auxiliary(
+                &crs,
+                &dir,
+                &HL_PROVEN_COMPACTLIST_TEST_ZKV2
+                    .proof_info
+                    .unwrap()
+                    .params_filename,
+            );
+
+            // Store the associated client key to be able to decrypt the ciphertexts in the list
+            store_versioned_auxiliary(
+                &hl_client_key,
+                &dir,
+                &HL_PROVEN_COMPACTLIST_TEST_ZKV2.key_filename,
+            );
+
+            store_versioned_auxiliary(
+                &compact_pub_key,
+                &dir,
+                &HL_PROVEN_COMPACTLIST_TEST_ZKV2
+                    .proof_info
+                    .unwrap()
+                    .public_key_filename,
+            );
+
+            let mut proven_builder = ProvenCompactCiphertextList::builder(&compact_pub_key);
+            proven_builder.push(HL_PROVEN_COMPACTLIST_TEST_ZKV2.clear_values[0] as u8);
+
+            let proven_list_packed = proven_builder
+                .build_with_proof_packed(
+                    &crs,
+                    HL_PROVEN_COMPACTLIST_TEST_ZKV2
+                        .proof_info
+                        .unwrap()
+                        .metadata
+                        .as_bytes(),
+                    ZkComputeLoad::Proof,
+                )
+                .unwrap();
+
+            store_versioned_test(
+                &proven_list_packed,
+                &dir,
+                &HL_PROVEN_COMPACTLIST_TEST_ZKV2.test_filename,
+            );
+        }
 
         vec![
             TestMetadata::HlClientKey(HL_CLIENTKEY_TEST),
             TestMetadata::HlServerKey(HL_COMPRESSED_SERVERKEY_TEST),
             TestMetadata::HlServerKey(HL_SERVERKEY_WITH_COMPRESSION_TEST),
+            TestMetadata::HlHeterogeneousCiphertextList(HL_PROVEN_COMPACTLIST_TEST_ZKV2),
         ]
     }
 }

utils/tfhe-backward-compat-data/crates/generate_1_5/src/utils.rs

@@ -2,12 +2,13 @@ use std::path::Path;
 use tfhe::core_crypto::prelude::{
     CiphertextModulusLog, LweCiphertextCount, TUniform, UnsignedInteger,
 };
+use tfhe::shortint::MultiBitPBSParameters;
 use tfhe::shortint::parameters::list_compression::{
     ClassicCompressionParameters, MultiBitCompressionParameters,
 };
+use tfhe::shortint::parameters::noise_squashing::NoiseSquashingMultiBitParameters;
 use tfhe::shortint::parameters::*;
 use tfhe::shortint::prelude::ModulusSwitchType;
-use tfhe::shortint::{MultiBitPBSParameters, PBSParameters};
 use tfhe_backward_compat_data::generate::*;
 use tfhe_backward_compat_data::*;
 use tfhe_versionable::Versionize;
@@ -53,6 +54,40 @@ where
     }
 }
 
+impl ConvertParams<ModulusSwitchNoiseReductionParams> for TestModulusSwitchNoiseReductionParams {
+    fn convert(self) -> ModulusSwitchNoiseReductionParams {
+        let TestModulusSwitchNoiseReductionParams {
+            modulus_switch_zeros_count,
+            ms_bound,
+            ms_r_sigma_factor,
+            ms_input_variance,
+        } = self;
+
+        ModulusSwitchNoiseReductionParams {
+            modulus_switch_zeros_count: LweCiphertextCount(modulus_switch_zeros_count),
+            ms_bound: NoiseEstimationMeasureBound(ms_bound),
+            ms_r_sigma_factor: RSigmaFactor(ms_r_sigma_factor),
+            ms_input_variance: Variance(ms_input_variance),
+        }
+    }
+}
+
+impl ConvertParams<ModulusSwitchType> for TestModulusSwitchType {
+    fn convert(self) -> ModulusSwitchType {
+        match self {
+            TestModulusSwitchType::Standard => ModulusSwitchType::Standard,
+            TestModulusSwitchType::DriftTechniqueNoiseReduction(
+                test_modulus_switch_noise_reduction_params,
+            ) => ModulusSwitchType::DriftTechniqueNoiseReduction(
+                test_modulus_switch_noise_reduction_params.convert(),
+            ),
+            TestModulusSwitchType::CenteredMeanNoiseReduction => {
+                ModulusSwitchType::CenteredMeanNoiseReduction
+            }
+        }
+    }
+}
+
 impl ConvertParams<ClassicPBSParameters> for TestClassicParameterSet {
     fn convert(self) -> ClassicPBSParameters {
         let TestClassicParameterSet {
@@ -101,40 +136,6 @@ impl ConvertParams<ClassicPBSParameters> for TestClassicParameterSet {
     }
 }
 
-impl ConvertParams<ModulusSwitchNoiseReductionParams> for TestModulusSwitchNoiseReductionParams {
-    fn convert(self) -> ModulusSwitchNoiseReductionParams {
-        let TestModulusSwitchNoiseReductionParams {
-            modulus_switch_zeros_count,
-            ms_bound,
-            ms_r_sigma_factor,
-            ms_input_variance,
-        } = self;
-
-        ModulusSwitchNoiseReductionParams {
-            modulus_switch_zeros_count: LweCiphertextCount(modulus_switch_zeros_count),
-            ms_bound: NoiseEstimationMeasureBound(ms_bound),
-            ms_r_sigma_factor: RSigmaFactor(ms_r_sigma_factor),
-            ms_input_variance: Variance(ms_input_variance),
-        }
-    }
-}
-
-impl ConvertParams<ModulusSwitchType> for TestModulusSwitchType {
-    fn convert(self) -> ModulusSwitchType {
-        match self {
-            TestModulusSwitchType::Standard => ModulusSwitchType::Standard,
-            TestModulusSwitchType::DriftTechniqueNoiseReduction(
-                test_modulus_switch_noise_reduction_params,
-            ) => ModulusSwitchType::DriftTechniqueNoiseReduction(
-                test_modulus_switch_noise_reduction_params.convert(),
-            ),
-            TestModulusSwitchType::CenteredMeanNoiseReduction => {
-                ModulusSwitchType::CenteredMeanNoiseReduction
-            }
-        }
-    }
-}
-
 impl ConvertParams<MultiBitPBSParameters> for TestMultiBitParameterSet {
     fn convert(self) -> MultiBitPBSParameters {
         let TestMultiBitParameterSet {
@@ -184,17 +185,62 @@ impl ConvertParams<MultiBitPBSParameters> for TestMultiBitParameterSet {
     }
 }
 
-impl ConvertParams<PBSParameters> for TestParameterSet {
+impl ConvertParams<KeySwitch32PBSParameters> for TestKS32ParameterSet {
-    fn convert(self) -> PBSParameters {
+    fn convert(self) -> KeySwitch32PBSParameters {
+        let TestKS32ParameterSet {
+            lwe_dimension,
+            glwe_dimension,
+            polynomial_size,
+            lwe_noise_distribution,
+            glwe_noise_distribution,
+            pbs_base_log,
+            pbs_level,
+            ks_base_log,
+            ks_level,
+            message_modulus,
+            ciphertext_modulus,
+            carry_modulus,
+            max_noise_level,
+            log2_p_fail,
+            modulus_switch_noise_reduction_params,
+            post_keyswitch_ciphertext_modulus,
+        } = self;
+
+        KeySwitch32PBSParameters {
+            lwe_dimension: LweDimension(lwe_dimension),
+            glwe_dimension: GlweDimension(glwe_dimension),
+            polynomial_size: PolynomialSize(polynomial_size),
+            lwe_noise_distribution: lwe_noise_distribution.convert(),
+            glwe_noise_distribution: glwe_noise_distribution.convert(),
+            pbs_base_log: DecompositionBaseLog(pbs_base_log),
+            pbs_level: DecompositionLevelCount(pbs_level),
+            ks_base_log: DecompositionBaseLog(ks_base_log),
+            ks_level: DecompositionLevelCount(ks_level),
+            message_modulus: MessageModulus(message_modulus as u64),
+            carry_modulus: CarryModulus(carry_modulus as u64),
+            max_noise_level: MaxNoiseLevel::new(max_noise_level as u64),
+            log2_p_fail,
+            post_keyswitch_ciphertext_modulus: CiphertextModulus32::try_new(
+                post_keyswitch_ciphertext_modulus,
+            )
+            .unwrap(),
+            ciphertext_modulus: CiphertextModulus::try_new(ciphertext_modulus).unwrap(),
+            modulus_switch_noise_reduction_params: modulus_switch_noise_reduction_params.convert(),
+        }
+    }
+}
+
+impl ConvertParams<AtomicPatternParameters> for TestParameterSet {
+    fn convert(self) -> AtomicPatternParameters {
         match self {
             TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => {
-                PBSParameters::PBS(test_classic_parameter_set.convert())
+                AtomicPatternParameters::Standard(test_classic_parameter_set.convert().into())
             }
             TestParameterSet::TestMultiBitParameterSet(test_parameter_set_multi_bit) => {
-                PBSParameters::MultiBitPBS(test_parameter_set_multi_bit.convert())
+                AtomicPatternParameters::Standard(test_parameter_set_multi_bit.convert().into())
             }
-            TestParameterSet::TestKS32ParameterSet(_) => {
+            TestParameterSet::TestKS32ParameterSet(test_parameter_set_ks32) => {
-                panic!("unsupported ks32 parameters for version")
+                AtomicPatternParameters::KeySwitch32(test_parameter_set_ks32.convert())
             }
         }
     }
@@ -246,3 +292,127 @@ impl ConvertParams<CompressionParameters> for TestCompressionParameterSet {
         }
     }
 }
+
+impl ConvertParams<NoiseSquashingParameters> for TestNoiseSquashingParams {
+    fn convert(self) -> NoiseSquashingParameters {
+        let TestNoiseSquashingParams {
+            glwe_dimension,
+            polynomial_size,
+            glwe_noise_distribution,
+            decomp_base_log,
+            decomp_level_count,
+            modulus_switch_noise_reduction_params,
+            message_modulus,
+            carry_modulus,
+            ciphertext_modulus,
+        } = self;
+
+        NoiseSquashingParameters::Classic(NoiseSquashingClassicParameters {
+            glwe_dimension: GlweDimension(glwe_dimension),
+            polynomial_size: PolynomialSize(polynomial_size),
+            glwe_noise_distribution: glwe_noise_distribution.convert(),
+            decomp_base_log: DecompositionBaseLog(decomp_base_log),
+            decomp_level_count: DecompositionLevelCount(decomp_level_count),
+            modulus_switch_noise_reduction_params: modulus_switch_noise_reduction_params.convert(),
+            message_modulus: MessageModulus(message_modulus as u64),
+            carry_modulus: CarryModulus(carry_modulus as u64),
+            ciphertext_modulus: CoreCiphertextModulus::try_new(ciphertext_modulus).unwrap(),
+        })
+    }
+}
+
+impl ConvertParams<NoiseSquashingParameters> for TestNoiseSquashingParamsMultiBit {
+    fn convert(self) -> NoiseSquashingParameters {
+        let TestNoiseSquashingParamsMultiBit {
+            glwe_dimension,
+            polynomial_size,
+            glwe_noise_distribution,
+            decomp_base_log,
+            decomp_level_count,
+            grouping_factor,
+            message_modulus,
+            carry_modulus,
+            ciphertext_modulus,
+        } = self;
+
+        NoiseSquashingParameters::MultiBit(NoiseSquashingMultiBitParameters {
+            glwe_dimension: GlweDimension(glwe_dimension),
+            polynomial_size: PolynomialSize(polynomial_size),
+            glwe_noise_distribution: glwe_noise_distribution.convert(),
+            decomp_base_log: DecompositionBaseLog(decomp_base_log),
+            decomp_level_count: DecompositionLevelCount(decomp_level_count),
+            grouping_factor: LweBskGroupingFactor(grouping_factor),
+            message_modulus: MessageModulus(message_modulus as u64),
+            carry_modulus: CarryModulus(carry_modulus as u64),
+            ciphertext_modulus: CoreCiphertextModulus::try_new(ciphertext_modulus).unwrap(),
+            deterministic_execution: false,
+        })
+    }
+}
+
+impl ConvertParams<ShortintKeySwitchingParameters> for TestKeySwitchingParams {
+    fn convert(self) -> ShortintKeySwitchingParameters {
+        ShortintKeySwitchingParameters {
+            ks_level: DecompositionLevelCount(self.ks_level),
+            ks_base_log: DecompositionBaseLog(self.ks_base_log),
+            destination_key: match &*self.destination_key {
+                "big" => EncryptionKeyChoice::Big,
+                "small" => EncryptionKeyChoice::Small,
+                _ => panic!("Invalid encryption key choice"),
+            },
+        }
+    }
+}
+
+impl ConvertParams<CompactPublicKeyEncryptionParameters>
+    for TestCompactPublicKeyEncryptionParameters
+{
+    fn convert(self) -> CompactPublicKeyEncryptionParameters {
+        CompactPublicKeyEncryptionParameters {
+            encryption_lwe_dimension: LweDimension(self.encryption_lwe_dimension),
+            encryption_noise_distribution: self.encryption_noise_distribution.convert(),
+            message_modulus: MessageModulus(self.message_modulus as u64),
+            carry_modulus: CarryModulus(self.carry_modulus as u64),
+            ciphertext_modulus: CoreCiphertextModulus::try_new(self.ciphertext_modulus).unwrap(),
+            expansion_kind: match &*self.expansion_kind {
+                "requires_casting" => CompactCiphertextListExpansionKind::RequiresCasting,
+                _ => panic!("Invalid expansion kind"),
+            },
+            zk_scheme: match &*self.zk_scheme {
+                "zkv1" => SupportedCompactPkeZkScheme::V1,
+                "zkv2" => SupportedCompactPkeZkScheme::V2,
+                _ => panic!("Invalid zk scheme"),
+            },
+        }
+    }
+}
+
+impl ConvertParams<NoiseSquashingCompressionParameters>
+    for TestNoiseSquashingCompressionParameters
+{
+    fn convert(self) -> NoiseSquashingCompressionParameters {
+        let TestNoiseSquashingCompressionParameters {
+            packing_ks_level,
+            packing_ks_base_log,
+            packing_ks_polynomial_size,
+            packing_ks_glwe_dimension,
+            lwe_per_glwe,
+            packing_ks_key_noise_distribution,
+            message_modulus,
+            carry_modulus,
+            ciphertext_modulus,
+        } = self;
+
+        NoiseSquashingCompressionParameters {
+            packing_ks_level: DecompositionLevelCount(packing_ks_level),
+            packing_ks_base_log: DecompositionBaseLog(packing_ks_base_log),
+            packing_ks_polynomial_size: PolynomialSize(packing_ks_polynomial_size),
+            packing_ks_glwe_dimension: GlweDimension(packing_ks_glwe_dimension),
+            lwe_per_glwe: LweCiphertextCount(lwe_per_glwe),
+            packing_ks_key_noise_distribution: packing_ks_key_noise_distribution.convert(),
+            message_modulus: MessageModulus(message_modulus as u64),
+            carry_modulus: CarryModulus(carry_modulus as u64),
+            ciphertext_modulus: CoreCiphertextModulus::try_new(ciphertext_modulus).unwrap(),
+        }
+    }
+}

utils/tfhe-backward-compat-data/data/1_5/high_level_api/client_key_for_zk.cbor

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87dbbf9c40468c4a86083be5e0c8775bb3d3493d43b0a60f91510e57b20739e7
+size 3286

utils/tfhe-backward-compat-data/data/1_5/high_level_api/hl_proven_list_zkv2_1_5.bcode

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b55dacf133a9872eda68be150cd314476e6e92177701a934139d17009983f66
+size 3057

utils/tfhe-backward-compat-data/data/1_5/high_level_api/hl_proven_list_zkv2_1_5.cbor

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b60e83254a0f7449647741711e019a73743fd94b550b2188bedaeb3121e773a7
+size 3780

utils/tfhe-backward-compat-data/data/1_5/high_level_api/public_key.cbor

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:419d5ad2af241abde2fdd31d81f505cb6c39fc3ac7c0de22cfdbac9618c81d73
+size 990

utils/tfhe-backward-compat-data/data/1_5/high_level_api/zk_pke_crs.cbor

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1e2db119c439f3c7093e25925aa9796e5f30edb2a934ef7d2af79731f3e9271
+size 4385130

utils/tfhe-backward-compat-data/data/high_level_api.ron

@@ -845,4 +845,24 @@
             compressed: false,
         )),
     ),
+    (
+        tfhe_version_min: "1.5",
+        tfhe_module: "high_level_api",
+        metadata: HlHeterogeneousCiphertextList((
+            test_filename: "hl_proven_list_zkv2_1_5",
+            key_filename: "client_key_for_zk",
+            compressed: false,
+            proof_info: Some((
+                public_key_filename: "public_key",
+                params_filename: "zk_pke_crs",
+                metadata: "2vdrawkcab",
+            )),
+            clear_values: [
+                17,
+            ],
+            data_kinds: [
+                Unsigned,
+            ],
+        )),
+    ),
 ]