fix(zk-pok): Check Modulus of deserialized Fp

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

@@ -416,3 +416,27 @@ pub mod g2 {
     /// 107680854723992552431070996218129928499826544031468382031848626814251381379173928074140221537929995580031433096217223703806029068859074
     pub const G2_GENERATOR_Y_C1: Fq = MontFp!("107680854723992552431070996218129928499826544031468382031848626814251381379173928074140221537929995580031433096217223703806029068859074");
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::serialization::{InvalidFpError, SerializableFp};
+
+    use super::Fq;
+    use ark_ff::Field;
+
+    #[test]
+    fn test_serialization() {
+        // This one is only used to have the correct number of serialized bytes
+        let a = Fq::ONE;
+        let s: SerializableFp = a.into();
+
+        let mut data = vec![];
+        bincode::serialize_into(&mut data, &s).unwrap();
+        // First u64 is the vec size
+        data[std::mem::size_of::<u64>()..].fill(u8::MAX);
+
+        let s2: SerializableFp = bincode::deserialize(&data).unwrap();
+        let a2 = Fq::try_from(s2);
+        assert!(matches!(a2, Err(InvalidFpError::GreaterThanModulus)));
+    }
+}

tfhe-zk-pok/src/curve_api/bls12_381.rs

@@ -529,7 +529,7 @@ mod g2 {
 }
 
 mod gt {
-    use crate::serialization::InvalidArraySizeError;
+    use crate::serialization::InvalidFpError;
 
     use super::*;
     use ark_ec::pairing::Pairing;
@@ -550,7 +550,7 @@ mod gt {
     }
 
     impl TryFrom<SerializableFp12> for Gt {
-        type Error = InvalidArraySizeError;
+        type Error = InvalidFpError;
 
         fn try_from(value: SerializableFp12) -> Result<Self, Self::Error> {
             Ok(Self {
@@ -682,7 +682,7 @@ mod gt {
 }
 
 mod zp {
-    use crate::serialization::InvalidArraySizeError;
+    use crate::serialization::InvalidFpError;
 
     use super::*;
     use ark_ff::Fp;
@@ -737,7 +737,7 @@ mod zp {
         }
     }
     impl TryFrom<SerializableFp> for Zp {
-        type Error = InvalidArraySizeError;
+        type Error = InvalidFpError;
 
         fn try_from(value: SerializableFp) -> Result<Self, Self::Error> {
             Ok(Self {

tfhe-zk-pok/src/curve_api/bls12_446.rs

@@ -958,7 +958,7 @@ mod gt {
 mod zp {
     use super::*;
     use crate::curve_446::FrConfig;
-    use crate::serialization::InvalidArraySizeError;
+    use crate::serialization::InvalidFpError;
     use ark_ff::{Fp, FpConfig, MontBackend, PrimeField};
     use tfhe_versionable::Versionize;
     use zeroize::{Zeroize, ZeroizeOnDrop};
@@ -1013,7 +1013,7 @@ mod zp {
         }
     }
     impl TryFrom<SerializableFp> for Zp {
-        type Error = InvalidArraySizeError;
+        type Error = InvalidFpError;
 
         fn try_from(value: SerializableFp) -> Result<Self, Self::Error> {
             Ok(Self {

tfhe-zk-pok/src/serialization.rs

@@ -12,7 +12,9 @@ use crate::backward_compatibility::{
 };
 use ark_ec::short_weierstrass::{Affine, SWCurveConfig};
 use ark_ec::AffineRepr;
-use ark_ff::{BigInt, Field, Fp, Fp2, Fp6, Fp6Config, FpConfig, QuadExtConfig, QuadExtField};
+use ark_ff::{
+    BigInt, Field, Fp, Fp2, Fp6, Fp6Config, FpConfig, PrimeField, QuadExtConfig, QuadExtField,
+};
 use serde::{Deserialize, Serialize};
 use tfhe_versionable::Versionize;
 
@@ -47,6 +49,34 @@ impl Display for InvalidArraySizeError {
 
 impl Error for InvalidArraySizeError {}
 
+#[derive(Debug)]
+pub enum InvalidFpError {
+    InvalidArraySizeError(InvalidArraySizeError),
+    GreaterThanModulus,
+}
+
+impl From<InvalidArraySizeError> for InvalidFpError {
+    fn from(value: InvalidArraySizeError) -> Self {
+        Self::InvalidArraySizeError(value)
+    }
+}
+
+impl Display for InvalidFpError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::InvalidArraySizeError(e) => e.fmt(f),
+            Self::GreaterThanModulus => {
+                write!(
+                    f,
+                    "The deserialized value was bigger than what its type modulus allowed"
+                )
+            }
+        }
+    }
+}
+
+impl Error for InvalidFpError {}
+
 /// Tries to convert a Vec into a constant size array, and returns an [`InvalidArraySizeError`] if
 /// the size does not match
 pub(crate) fn try_vec_to_array<T, const N: usize>(
@@ -77,16 +107,20 @@ impl<P: FpConfig<N>, const N: usize> From<Fp<P, N>> for SerializableFp {
 }
 
 impl<P: FpConfig<N>, const N: usize> TryFrom<SerializableFp> for Fp<P, N> {
-    type Error = InvalidArraySizeError;
+    type Error = InvalidFpError;
 
     fn try_from(value: SerializableFp) -> Result<Self, Self::Error> {
-        Ok(Fp(BigInt(try_vec_to_array(value.val)?), PhantomData))
+        let fp = BigInt(try_vec_to_array(value.val)?);
+        if fp >= Fp::<P, N>::MODULUS {
+            return Err(InvalidFpError::GreaterThanModulus);
+        }
+        Ok(Fp(fp, PhantomData))
     }
 }
 
 #[derive(Debug)]
 pub enum InvalidSerializedAffineError {
-    InvalidFp(InvalidArraySizeError),
+    InvalidFp(InvalidFpError),
     InvalidCompressedXCoordinate,
 }
 
@@ -115,8 +149,8 @@ impl Error for InvalidSerializedAffineError {
     }
 }
 
-impl From<InvalidArraySizeError> for InvalidSerializedAffineError {
-    fn from(value: InvalidArraySizeError) -> Self {
+impl From<InvalidFpError> for InvalidSerializedAffineError {
+    fn from(value: InvalidFpError) -> Self {
         Self::InvalidFp(value)
     }
 }
@@ -163,7 +197,7 @@ impl<F> SerializableAffine<F> {
 
 impl<F, C: SWCurveConfig> TryFrom<SerializableAffine<F>> for Affine<C>
 where
-    F: TryInto<C::BaseField, Error = InvalidArraySizeError>,
+    F: TryInto<C::BaseField, Error = InvalidFpError>,
 {
     type Error = InvalidSerializedAffineError;
 
@@ -207,9 +241,9 @@ where
 
 impl<F, P: QuadExtConfig> TryFrom<SerializableQuadExtField<F>> for QuadExtField<P>
 where
-    F: TryInto<P::BaseField, Error = InvalidArraySizeError>,
+    F: TryInto<P::BaseField, Error = InvalidFpError>,
 {
-    type Error = InvalidArraySizeError;
+    type Error = InvalidFpError;
 
     fn try_from(value: SerializableQuadExtField<F>) -> Result<Self, Self::Error> {
         Ok(QuadExtField {
@@ -244,9 +278,9 @@ where
 
 impl<F, P6: Fp6Config> TryFrom<SerializableCubicExtField<F>> for Fp6<P6>
 where
-    F: TryInto<Fp2<P6::Fp2Config>, Error = InvalidArraySizeError>,
+    F: TryInto<Fp2<P6::Fp2Config>, Error = InvalidFpError>,
 {
-    type Error = InvalidArraySizeError;
+    type Error = InvalidFpError;
 
     fn try_from(value: SerializableCubicExtField<F>) -> Result<Self, Self::Error> {
         Ok(Fp6 {