Fix divergent behavior in integer backends

src/backend/num_bigint.rs

@@ -75,6 +75,17 @@ impl Integer {
     }
     /// Parses the integer using the given radix
     pub fn from_str_radix(s: &str, radix: u16) -> Option<Self> {
+        // num-bigint already enforces these checks, but we double-enforce them
+        // to make sure they are in sync with what we already enforce for rug.
+        // See RugInteger::from_str_radix
+        if !s
+            .chars()
+            .enumerate()
+            .skip_while(|&(i, c)| i == 0 && (c == '+' || c == '-'))
+            .all(|(_, c)| c.is_ascii_alphanumeric())
+        {
+            return None;
+        }
         num_traits::Num::from_str_radix(s, radix.into())
             .ok()
             .map(Integer)
@@ -451,7 +462,7 @@ impl quickcheck::Arbitrary for Integer {
             if prev.cmp0().is_eq() {
                 None
             } else {
-                prev >>= 1;
+                prev /= 2;
                 Some(prev.clone())
             }
         }))

src/backend/rug.rs

@@ -76,6 +76,18 @@ impl Integer {
     }
     /// Parses the integer using the given radix
     pub fn from_str_radix(s: &str, radix: u16) -> Option<Self> {
+        // rug accepts strings that have whitespaces in them, integer is parsed while
+        // ignoring whitespaces, even in the middle of the number. This behavior is
+        // different from num-bigint backend, and it is strange. We manually restrict
+        // strings to be ascii alphanum
+        if !s
+            .chars()
+            .enumerate()
+            .skip_while(|&(i, c)| i == 0 && (c == '+' || c == '-'))
+            .all(|(_, c)| c.is_ascii_alphanumeric())
+        {
+            return None;
+        }
         rug::Integer::from_str_radix(s, radix.into())
             .ok()
             .map(Integer)
@@ -344,7 +356,7 @@ impl quickcheck::Arbitrary for Integer {
             if prev.cmp0().is_eq() {
                 None
             } else {
-                prev >>= 1;
+                prev /= 2;
                 Some(prev.clone())
             }
         }))

tests/integration/backend.rs

@@ -180,6 +180,17 @@ quickcheck::quickcheck! {
         // It matters to check if one returns `Yes|Probably`, and the other returns `No`
         matches!((r1, r2), (IsPrime::Yes | IsPrime::Probably, IsPrime::Yes | IsPrime::Probably) | (IsPrime::No, IsPrime::No))
     }
+
+    fn from_radix(s: AsciiString) -> bool {
+        let nbi = NbiInteger::from_str_radix(&s.0, 16);
+        let rug = RugInteger::from_str_radix(&s.0, 16);
+        eprintln!("{nbi:?}, {rug:?}");
+        match (nbi, rug) {
+            (Some(a), Some(b)) => a.equals(b),
+            (None, None) => true,
+            _ => false
+        }
+    }
 }
 
 ///// Helper traits for macro /////
@@ -455,3 +466,16 @@ impl<'a> Arg<'a> for Prng {
         &mut self.rng
     }
 }
+
+#[derive(Debug, Clone)]
+struct AsciiString(String);
+impl quickcheck::Arbitrary for AsciiString {
+    fn arbitrary(g: &mut quickcheck::Gen) -> Self {
+        let size = u8::arbitrary(g) % 32;
+        let s = std::iter::repeat_with(|| u8::arbitrary(g) & 0x7F)
+            .take(usize::from(size))
+            .map(char::from)
+            .collect();
+        Self(s)
+    }
+}

tests/integration/main.rs

@@ -217,3 +217,8 @@ fn random_key_for_tests(rng: &mut impl rand_core::RngCore) -> DecryptionKey {
     let q = Integer::generate_safe_prime(rng, 512);
     DecryptionKey::from_primes(p, q).unwrap()
 }
+
+#[test]
+fn bigint_from_radix_prohibits_whitespaces() {
+    assert_eq!(Integer::from_str_radix("123 4", 10), None)
+}