Add modulus range check when creating FieldElement from hex (#1020)

* Add modulus range check when creating Felt from hex

* Adapt from_hex test case that uses str with 64 ones

Author: gabrielbosio

crates/math/src/errors.rs

@@ -13,6 +13,7 @@ pub enum CreationError {
     InvalidHexString,
     InvalidDecString,
     HexStringIsTooBig,
+    RepresentativeOutOfRange,
     EmptyString,
 }
 

crates/math/src/field/element.rs

@@ -608,6 +608,8 @@ impl<F: IsPrimeField> FieldElement<F> {
     /// Returns a `CreationError::EmptyString` if the input string is empty.
     /// Returns a `CreationError::HexStringIsTooBig` if the the input hex string is bigger than the
     /// maximum amount of characters for this element.
+    /// Returns a `CreationError::RepresentativeOutOfRange` if the representative of the value is
+    /// out of the range [0, p-1] where p is the modulus.
     pub fn from_hex(hex_string: &str) -> Result<Self, CreationError> {
         if hex_string.is_empty() {
             return Err(CreationError::EmptyString);
@@ -980,6 +982,14 @@ mod tests {
         assert!(FE::from_hex("").is_err());
     }
 
+    #[test]
+    fn construct_new_field_element_from_value_bigger_than_modulus() {
+        type F = Stark252PrimeField;
+        type FE = FieldElement<F>;
+        // A number that consists of 255 1s is bigger than the `Stark252PrimeField` modulus
+        assert!(FE::from_hex(&format!("0x{}", "f".repeat(65))).is_err());
+    }
+
     prop_compose! {
         fn field_element()(num in any::<u64>().prop_filter("Avoid null coefficients", |x| x != &0)) -> FieldElement::<Stark252PrimeField> {
             FieldElement::<Stark252PrimeField>::from(num)

crates/math/src/field/fields/montgomery_backed_prime_fields.rs

@@ -1,3 +1,4 @@
+use crate::errors::CreationError;
 use crate::field::element::FieldElement;
 use crate::field::errors::FieldError;
 use crate::field::traits::{HasDefaultTranscript, IsPrimeField};
@@ -305,8 +306,12 @@ where
         evaluated_bit + 1
     }
 
-    fn from_hex(hex_string: &str) -> Result<Self::BaseType, crate::errors::CreationError> {
+    fn from_hex(hex_string: &str) -> Result<Self::BaseType, CreationError> {
         let integer = Self::BaseType::from_hex(hex_string)?;
+        if integer > M::MODULUS {
+            return Err(CreationError::RepresentativeOutOfRange);
+        }
+
         Ok(MontgomeryAlgorithms::cios(
             &integer,
             &MontgomeryBackendPrimeField::<M, NUM_LIMBS>::R2,
@@ -1294,9 +1299,14 @@ mod tests_u256_prime_fields {
     }
 
     #[test]
-    fn creating_a_field_element_from_hex_works_on_the_size_limit() {
+    fn creating_a_field_element_from_hex_bigger_than_modulus_errors() {
+        // A number that consists of 255 1s is bigger than the `U256FP1` modulus
         let a = U256FP1Element::from_hex(&"f".repeat(64));
-        assert!(a.is_ok());
+        assert!(a.is_err());
+        assert_eq!(
+            a.unwrap_err(),
+            crate::errors::CreationError::RepresentativeOutOfRange
+        )
     }
 
     #[test]