Ns/plug zk v2

tfhe-zk-pok/src/backward_compatibility/mod.rs

@@ -60,14 +60,14 @@ impl Display for IncompleteProof {
 impl Error for IncompleteProof {}
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum GroupElementsVersions<G: Curve> {
+    #[allow(dead_code)]
     V0(GroupElements<G>),
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum SerializableGroupElementsVersions {
+    #[allow(dead_code)]
     V0(SerializableGroupElements),
 }
 

tfhe-zk-pok/src/backward_compatibility/pke.rs

@@ -49,8 +49,8 @@ pub enum ProofVersions<G: Curve> {
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum ComputeLoadProofFieldVersions<G: Curve> {
+    #[allow(dead_code)]
     V0(ComputeLoadProofFields<G>),
 }
 
@@ -107,11 +107,11 @@ where
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum CompressedComputeLoadProofFieldsVersions<G: Curve>
 where
     G::G1: Compressible,
     G::G2: Compressible,
 {
+    #[allow(dead_code)]
     V0(CompressedComputeLoadProofFields<G>),
 }

tfhe-zk-pok/src/backward_compatibility/pke_v2.rs

@@ -62,8 +62,8 @@ pub enum ProofVersions<G: Curve> {
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
-pub(crate) enum ComputeLoadProofFieldVersions<G: Curve> {
+pub(crate) enum ComputeLoadProofFieldsVersions<G: Curve> {
+    #[allow(dead_code)]
     V0(ComputeLoadProofFields<G>),
 }
 
@@ -132,11 +132,11 @@ where
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum CompressedComputeLoadProofFieldsVersions<G: Curve>
 where
     G::G1: Compressible,
     G::G2: Compressible,
 {
+    #[allow(dead_code)]
     V0(CompressedComputeLoadProofFields<G>),
 }

tfhe-zk-pok/src/proofs/mod.rs

@@ -153,6 +153,7 @@ fn assert_pke_proof_preconditions(
     big_d: usize,
     big_d_max: usize,
 ) {
+    assert!(k_max <= d);
     assert_eq!(c1.len(), d);
     assert_eq!(e1.len(), d);
 

tfhe-zk-pok/src/proofs/pke_v2.rs

@@ -2,7 +2,7 @@
 #![allow(non_snake_case)]
 
 use super::*;
-use crate::backward_compatibility::pke_v2::{CompressedProofVersions, ProofVersions};
+use crate::backward_compatibility::pke_v2::*;
 use crate::backward_compatibility::BoundVersions;
 use crate::curve_api::{CompressedG1, CompressedG2};
 use crate::four_squares::*;
@@ -29,7 +29,7 @@ fn bit_iter(x: u64, nbits: u32) -> impl Iterator<Item = bool> {
         serialize = "PublicParams<G>: Into<SerializablePKEv2PublicParams>"
     )
 )]
-#[versionize(convert = SerializablePKEv2PublicParams)]
+#[versionize(try_convert = SerializablePKEv2PublicParams)]
 pub struct PublicParams<G: Curve> {
     pub(crate) g_lists: GroupElements<G>,
     pub(crate) D: usize,
@@ -300,7 +300,8 @@ impl<G: Curve> Proof<G> {
 
 /// These fields can be pre-computed on the prover side in the faster Verifier scheme. If that's the
 /// case, they should be included in the proof.
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Versionize)]
+#[versionize(ComputeLoadProofFieldsVersions)]
 pub(crate) struct ComputeLoadProofFields<G: Curve> {
     pub(crate) C_hat_h3: G::G2,
     pub(crate) C_hat_w: G::G2,
@@ -332,11 +333,12 @@ where
     pub(crate) compute_load_proof_fields: Option<CompressedComputeLoadProofFields<G>>,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Versionize)]
 #[serde(bound(
     deserialize = "G: Curve, CompressedG1<G>: serde::Deserialize<'de>, CompressedG2<G>: serde::Deserialize<'de>",
     serialize = "G: Curve, CompressedG1<G>: serde::Serialize, CompressedG2<G>: serde::Serialize"
 ))]
+#[versionize(CompressedComputeLoadProofFieldsVersions)]
 pub(crate) struct CompressedComputeLoadProofFields<G: Curve>
 where
     G::G1: Compressible,
@@ -496,6 +498,12 @@ pub fn compute_crs_params(
     msbs_zero_padding_bit_count: u64,
     bound_type: Bound,
 ) -> (usize, usize, u128, usize) {
+    assert!(
+        k <= d,
+        "Invalid parameters for zk_pok, the maximum number of messages k should be smaller \
+than the lwe dimension d. Please pick a smaller k: k = {k}, d = {d}"
+    );
+
     let mut B_bound_squared = {
         (match bound_type {
             // GHL factor is 9.75, 9.75**2 = 95.0625
@@ -525,7 +533,7 @@ Please select a smaller B, d and/or k"
     // safely used for this
     assert!(
         m_bound <= 64,
-        "Invalid parameters for zk_pok, w e only support 64 bits integer. \
+        "Invalid parameters for zk_pok, we only support 64 bits integer. \
 The computed m parameter is {m_bound} > 64. Please select a smaller B, d and/or k"
     );
 

tfhe/benches/integer/zk_pke.rs

@@ -8,13 +8,14 @@ use rayon::prelude::*;
 use std::fs::{File, OpenOptions};
 use std::io::Write;
 use std::path::Path;
+use tfhe::core_crypto::prelude::LweCiphertextCount;
 use tfhe::integer::key_switching_key::KeySwitchingKey;
 use tfhe::integer::parameters::IntegerCompactCiphertextListExpansionMode;
 use tfhe::integer::{ClientKey, CompactPrivateKey, CompactPublicKey, ServerKey};
 use tfhe::keycache::NamedParam;
 use tfhe::shortint::parameters::classic::tuniform::p_fail_2_minus_64::ks_pbs::PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
-use tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
-use tfhe::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+use tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+use tfhe::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
 use tfhe::shortint::parameters::PBSParameters;
 use tfhe::zk::{CompactPkeCrs, ZkComputeLoad};
 use utilities::{write_to_json, OperatorType};
@@ -33,8 +34,8 @@ fn pke_zk_proof(c: &mut Criterion) {
         .measurement_time(std::time::Duration::from_secs(60));
 
     for (param_pke, _param_casting, param_fhe) in [(
-        PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
-        PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
+        V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
+        V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
         PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
     )] {
         let param_name = param_fhe.name();
@@ -64,8 +65,11 @@ fn pke_zk_proof(c: &mut Criterion) {
 
             let fhe_uint_count = bits / 64;
 
-            let crs =
-                CompactPkeCrs::from_shortint_params(param_pke, num_block * fhe_uint_count).unwrap();
+            let crs = CompactPkeCrs::from_shortint_params(
+                param_pke,
+                LweCiphertextCount(num_block * fhe_uint_count),
+            )
+            .unwrap();
 
             for compute_load in [ZkComputeLoad::Proof, ZkComputeLoad::Verify] {
                 let zk_load = match compute_load {
@@ -152,8 +156,8 @@ fn pke_zk_verify(c: &mut Criterion, results_file: &Path) {
         .expect("cannot open results file");
 
     for (param_pke, param_casting, param_fhe) in [(
-        PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
-        PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
+        V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
+        V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
         PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
     )] {
         let param_name = param_fhe.name();
@@ -183,8 +187,11 @@ fn pke_zk_verify(c: &mut Criterion, results_file: &Path) {
             let fhe_uint_count = bits / 64;
 
             println!("Generating CRS... ");
-            let crs =
-                CompactPkeCrs::from_shortint_params(param_pke, num_block * fhe_uint_count).unwrap();
+            let crs = CompactPkeCrs::from_shortint_params(
+                param_pke,
+                LweCiphertextCount(num_block * fhe_uint_count),
+            )
+            .unwrap();
 
             let shortint_params: PBSParameters = param_fhe.into();
 

tfhe/docs/guides/zk-pok.md

@@ -87,9 +87,9 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let params = tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
     // Indicate which parameters to use for the Compact Public Key encryption
-    let cpk_params = tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+    let cpk_params = tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
     // And parameters allowing to keyswitch/cast to the computation parameters.
-    let casting_params = tfhe::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+    let casting_params = tfhe::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
     // Enable the dedicated parameters on the config
     let config = tfhe::ConfigBuilder::with_custom_parameters(params)
         .use_dedicated_compact_public_key_parameters((cpk_params, casting_params));

tfhe/examples/utilities/params_to_file.rs

@@ -7,7 +7,7 @@ use tfhe::core_crypto::prelude::{DynamicDistribution, TUniform, UnsignedInteger}
 use tfhe::keycache::NamedParam;
 use tfhe::shortint::parameters::classic::compact_pk::ALL_PARAMETER_VEC_COMPACT_PK;
 use tfhe::shortint::parameters::classic::gaussian::ALL_PARAMETER_VEC_GAUSSIAN;
-use tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+use tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
 use tfhe::shortint::parameters::multi_bit::gaussian::ALL_MULTI_BIT_PARAMETER_VEC;
 use tfhe::shortint::parameters::{
     CompactPublicKeyEncryptionParameters, CompressionParameters, ShortintParameterSet,
@@ -285,7 +285,7 @@ fn main() {
 
     write_all_params_in_file(
         "shortint_cpke_parameters_lattice_estimator.sage",
-        &[PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64],
+        &[V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64],
         ParametersFormat::Lwe,
     );
 

tfhe/examples/utilities/print_doc_bench_parameters.rs

@@ -1,7 +1,7 @@
 use tfhe::keycache::NamedParam;
 use tfhe::shortint::parameters::classic::tuniform::p_fail_2_minus_64::ks_pbs::PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
-use tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
-use tfhe::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+use tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+use tfhe::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
 use tfhe::shortint::parameters::multi_bit::tuniform::p_fail_2_minus_64::ks_pbs_gpu::PARAM_GPU_MULTI_BIT_GROUP_3_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
 
 pub fn main() {
@@ -43,9 +43,9 @@ pub fn main() {
     println!("Compact Public Key parameters (encryption + ZK):");
     println!(
         "{}",
-        stringify!(PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64)
+        stringify!(V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64)
     );
-    println!("{PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64:?}\n");
+    println!("{V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64:?}\n");
 
     println!("Corresponding compute FHE parameters:");
     println!(
@@ -57,7 +57,7 @@ pub fn main() {
     println!("Keyswitch from encryption + ZK to compute parameters:");
     println!(
         "{}",
-        stringify!(PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64)
+        stringify!(V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64)
     );
-    println!("{PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64:?}");
+    println!("{V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64:?}");
 }

tfhe/examples/utilities/shortint_key_sizes.rs

@@ -7,8 +7,8 @@ use std::io::Write;
 use std::path::Path;
 use tfhe::keycache::NamedParam;
 use tfhe::shortint::keycache::KEY_CACHE;
-use tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
-use tfhe::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+use tfhe::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+use tfhe::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
 use tfhe::shortint::parameters::list_compression::COMP_PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
 use tfhe::shortint::parameters::{
     PARAM_GPU_MULTI_BIT_GROUP_3_MESSAGE_1_CARRY_1_KS_PBS_GAUSSIAN_2M64,
@@ -222,7 +222,7 @@ fn tuniform_key_set_sizes(results_file: &Path) {
         &mut file,
     );
 
-    let param_pke = PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+    let param_pke = V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
     let param_pke_name = stringify!(PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64);
     let compact_private_key = CompactPrivateKey::new(param_pke);
     let compressed_pk = CompressedCompactPublicKey::new(&compact_private_key);
@@ -266,7 +266,7 @@ fn tuniform_key_set_sizes(results_file: &Path) {
         &mut file,
     );
 
-    let param_casting = PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+    let param_casting = V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
     let param_casting_name = stringify!(PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64);
     let compressed_casting_key = CompressedKeySwitchingKey::new(
         (&compact_private_key, None),

tfhe/src/c_api/high_level_api/zk.rs

@@ -23,13 +23,6 @@ impl From<ZkComputeLoad> for crate::zk::ZkComputeLoad {
 pub struct CompactPkeCrs(pub(crate) crate::core_crypto::entities::CompactPkeCrs);
 impl_destroy_on_type!(CompactPkeCrs);
 
-// Because we use a repr(transparent) for the CompactPkeCrs, cbindgen will define CompactPkeCrs as
-// an alias for CompactPkePublicParams. We need to define this struct even if it will not actually
-// be used in the C api.
-#[allow(unused)]
-pub struct CompactPkePublicParams(pub(crate) crate::core_crypto::entities::CompactPkePublicParams);
-impl_destroy_on_type!(CompactPkePublicParams);
-
 /// Serializes the CRS
 ///
 /// If compress is true, the data will be compressed (less serialized bytes), however, this makes
@@ -144,7 +137,7 @@ pub unsafe extern "C" fn compact_pke_crs_deserialize_from_params(
 
         *result = std::ptr::null_mut();
 
-        let deserialized: crate::core_crypto::entities::CompactPkePublicParams =
+        let deserialized: crate::core_crypto::entities::ZkCompactPkeV1PublicParams =
             bincode::deserialize(buffer_view.as_slice()).unwrap();
         let crs = deserialized.into();
 
@@ -170,7 +163,7 @@ pub unsafe extern "C" fn compact_pke_crs_safe_deserialize_from_params(
 
         let buffer_view: &[u8] = buffer_view.as_slice();
 
-        let deserialized: crate::core_crypto::entities::CompactPkePublicParams =
+        let deserialized: crate::core_crypto::entities::ZkCompactPkeV1PublicParams =
             crate::safe_serialization::DeserializationConfig::new(serialized_size_limit)
                 .disable_conformance()
                 .deserialize_from(buffer_view)

tfhe/src/c_api/shortint/parameters.rs

@@ -2,8 +2,8 @@ pub use crate::core_crypto::commons::dispersion::StandardDev;
 pub use crate::core_crypto::commons::parameters::{
     DecompositionBaseLog, DecompositionLevelCount, GlweDimension, LweDimension, PolynomialSize,
 };
-pub use crate::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
-pub use crate::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+pub use crate::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
+pub use crate::shortint::parameters::key_switching::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
 pub use crate::shortint::parameters::*;
 
 #[repr(C)]
@@ -243,8 +243,8 @@ impl ShortintCompactPublicKeyEncryptionParameters {
 pub static SHORTINT_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64:
     ShortintCompactPublicKeyEncryptionParameters =
     ShortintCompactPublicKeyEncryptionParameters::convert((
-        PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
-        PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
+        V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
+        V0_11_PARAM_KEYSWITCH_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64,
     ));
 
 macro_rules! expose_as_shortint_pbs_parameters(