Support signed multiplication and division, for ECDSA.

src/signed/div.rs

@@ -0,0 +1,156 @@
+macro_rules! div_impls
+{
+    ($name: ident, $uname: ident) => {
+        impl DivAssign<$name> for $name {
+            fn div_assign(&mut self, rhs: $name) {
+                self.div_assign(&rhs);
+            }
+        }
+
+        impl<'a> DivAssign<&'a $name> for $name {
+            fn div_assign(&mut self, rhs: &$name) {
+                let (q,r) = self.value.divmod(&rhs.value);
+                if self.negative ^ rhs.negative {
+                    self.value.value.copy_from_slice(&q.value);
+                    if !r.is_zero() {
+                        self.value += $uname::from(1u64);
+                    }
+                    self.negative = !self.value.is_zero();
+                } else {
+                    self.value.value.copy_from_slice(&q.value);
+                    self.negative = false;
+                }
+            }
+        }
+
+        impl Div<$name> for $name {
+            type Output = $name;
+
+            fn div(self, rhs: $name) -> $name
+            {
+                &self / &rhs
+            }
+        }
+
+        impl<'a> Div<&'a $name> for $name {
+            type Output = $name;
+
+            fn div(self, rhs: &$name) -> $name
+            {
+                &self / rhs
+            }
+        }
+
+        impl<'a> Div<$name> for &'a $name {
+            type Output = $name;
+
+            fn div(self, rhs: $name) -> $name
+            {
+                self / &rhs
+            }
+        }
+
+        impl<'a,'b> Div<&'a $name> for &'b $name {
+            type Output = $name;
+
+            fn div(self, rhs: &$name) -> $name
+            {
+                let mut outval = self.clone();
+                outval /= rhs;
+                outval
+            }
+        }
+
+        impl RemAssign<$name> for $name {
+            fn rem_assign(&mut self, rhs: $name) {
+                self.rem_assign(&rhs);
+            }
+        }
+
+        impl<'a> RemAssign<&'a $name> for $name {
+            fn rem_assign(&mut self, rhs: &$name) {
+                if rhs.negative != self.negative {
+                    self.negative = !self.negative;
+                    let modres = &self.value % &rhs.value;
+                    self.value.value.copy_from_slice(&rhs.value.value);
+                    self.value -= modres;
+                } else {
+                    self.value %= &rhs.value;
+                }
+            }
+        }
+
+        impl Rem<$name> for $name {
+            type Output = $name;
+
+            fn rem(self, rhs: $name) -> $name
+            {
+                &self % &rhs
+            }
+        }
+
+        impl<'a> Rem<&'a $name> for $name {
+            type Output = $name;
+
+            fn rem(self, rhs: &$name) -> $name
+            {
+                &self % rhs
+            }
+        }
+
+        impl<'a> Rem<$name> for &'a $name {
+            type Output = $name;
+
+            fn rem(self, rhs: $name) -> $name
+            {
+                self % &rhs
+            }
+        }
+
+        impl<'a,'b> Rem<&'a $name> for &'b $name {
+            type Output = $name;
+
+            fn rem(self, rhs: &$name) -> $name
+            {
+                let mut outval = self.clone();
+                outval %= rhs;
+                outval
+            }
+        }
+     }
+}
+
+#[cfg(test)]
+macro_rules! generate_sigdiv_tests {
+    ($sname: ident, $name: ident, $lname: ident) => {
+        #[test]
+        fn $lname() {
+            generate_sigdiv_tests!(body $sname, $name);
+        }
+    };
+    (ignore $sname: ident, $name: ident, $lname: ident) => {
+        #[test]
+        #[ignore]
+        fn $lname() {
+            generate_sigdiv_tests!(body $sname, $name);
+        }
+    };
+    (body $sname: ident, $name: ident) => {
+        let fname = build_test_path("sigdiv", stringify!($sname));
+        run_test(fname.to_string(), 4, |case| {
+            let (nega, abytes) = case.get("a").unwrap();
+            let (negb, bbytes) = case.get("b").unwrap();
+            let (negq, qbytes) = case.get("q").unwrap();
+            let (negr, rbytes) = case.get("r").unwrap();
+
+            let a = $sname::new(*nega, $name::from_bytes(abytes));
+            let b = $sname::new(*negb, $name::from_bytes(bbytes));
+            let q = $sname::new(*negq, $name::from_bytes(qbytes));
+            let r = $sname::new(*negr, $name::from_bytes(rbytes));
+            let d = &a / &b;
+            let m = &a % &b;
+            assert_eq!(q, d, "base div");
+            assert_eq!(r, m, "base mod");
+        });
+    };
+}

src/signed/invoc.rs

@@ -1,14 +1,38 @@
+signed_impls!(I192, U192);
+subtraction_impls!(I192, I256, U256);
+conversion_impls!(I192, U192, I256, U256);
+conversion_impls!(I192, U192, I512, U512);
+egcd_impls!(I256, U192, I192);
+modinv_impls!(U192, I256, U256);
+add_impls!(I256, I320, U320);
 signed_impls!(I256, U256);
+cmp_impls!(I256);
+shift_impls!(I256, U256);
+subtraction_impls!(I256, I320, U320);
+mul_impls!(I256, I512);
 conversion_impls!(I256, U256, I320, U320);
+conversion_impls!(I256, U256, I512, U512);
+conversion_impls!(I256, U256, I640, U640);
 egcd_impls!(I320, U256, I256);
+modinv_impls!(U256, I320, U320);
 add_impls!(I320, I384, U384);
 signed_impls!(I320, U320);
 cmp_impls!(I320);
 shift_impls!(I320, U320);
 subtraction_impls!(I320, I384, U384);
+mul_impls!(I320, I640);
 conversion_impls!(I320, U320, I384, U384);
+conversion_impls!(I320, U320, I640, U640);
 signed_impls!(I384, U384);
+subtraction_impls!(I384, I448, U448);
+conversion_impls!(I384, U384, I448, U448);
+conversion_impls!(I384, U384, I896, U896);
+signed_impls!(I448, U448);
+mul_impls!(I448, I896);
+conversion_impls!(I448, U448, I896, U896);
 signed_impls!(I512, U512);
+subtraction_impls!(I512, I576, U576);
+div_impls!(I512, U512);
 conversion_impls!(I512, U512, I576, U576);
 egcd_impls!(I576, U512, I512);
 modinv_impls!(U512, I576, U576);
@@ -18,7 +42,19 @@ cmp_impls!(I576);
 shift_impls!(I576, U576);
 subtraction_impls!(I576, I640, U640);
 conversion_impls!(I576, U576, I640, U640);
+conversion_impls!(I576, U576, I1280, U1280);
 signed_impls!(I640, U640);
+subtraction_impls!(I640, I704, U704);
+mul_impls!(I640, I1280);
+div_impls!(I640, U640);
+conversion_impls!(I640, U640, I704, U704);
+conversion_impls!(I640, U640, I1280, U1280);
+signed_impls!(I704, U704);
+signed_impls!(I896, U896);
+subtraction_impls!(I896, I960, U960);
+div_impls!(I896, U896);
+conversion_impls!(I896, U896, I960, U960);
+signed_impls!(I960, U960);
 signed_impls!(I1024, U1024);
 conversion_impls!(I1024, U1024, I1088, U1088);
 egcd_impls!(I1088, U1024, I1024);
@@ -30,6 +66,11 @@ shift_impls!(I1088, U1088);
 subtraction_impls!(I1088, I1152, U1152);
 conversion_impls!(I1088, U1088, I1152, U1152);
 signed_impls!(I1152, U1152);
+signed_impls!(I1280, U1280);
+subtraction_impls!(I1280, I1344, U1344);
+div_impls!(I1280, U1280);
+conversion_impls!(I1280, U1280, I1344, U1344);
+signed_impls!(I1344, U1344);
 signed_impls!(I1536, U1536);
 conversion_impls!(I1536, U1536, I1600, U1600);
 egcd_impls!(I1600, U1536, I1536);
@@ -113,6 +154,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_sigadd_tests!(I256, U256, i256, I320, U320);
     generate_sigadd_tests!(I320, U320, i320, I384, U384);
     generate_sigadd_tests!(I576, U576, i576, I640, U640);
     generate_sigadd_tests!(I1088, U1088, i1088, I1152, U1152);
@@ -128,9 +170,16 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_sigsub_tests!(I192, U192, i192, I256, U256);
+    generate_sigsub_tests!(I256, U256, i256, I320, U320);
     generate_sigsub_tests!(I320, U320, i320, I384, U384);
+    generate_sigsub_tests!(I384, U384, i384, I448, U448);
+    generate_sigsub_tests!(I512, U512, i512, I576, U576);
     generate_sigsub_tests!(I576, U576, i576, I640, U640);
+    generate_sigsub_tests!(I640, U640, i640, I704, U704);
+    generate_sigsub_tests!(I896, U896, i896, I960, U960);
     generate_sigsub_tests!(I1088, U1088, i1088, I1152, U1152);
+    generate_sigsub_tests!(I1280, U1280, i1280, I1344, U1344);
     generate_sigsub_tests!(I1600, U1600, i1600, I1664, U1664);
     generate_sigsub_tests!(I2112, U2112, i2112, I2176, U2176);
     generate_sigsub_tests!(I3136, U3136, i3136, I3200, U3200);
@@ -143,15 +192,22 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_signed_tests!(I192, U192, i192);
     generate_signed_tests!(I256, U256, i256);
     generate_signed_tests!(I320, U320, i320);
     generate_signed_tests!(I384, U384, i384);
+    generate_signed_tests!(I448, U448, i448);
     generate_signed_tests!(I512, U512, i512);
     generate_signed_tests!(I576, U576, i576);
     generate_signed_tests!(I640, U640, i640);
+    generate_signed_tests!(I704, U704, i704);
+    generate_signed_tests!(I896, U896, i896);
+    generate_signed_tests!(I960, U960, i960);
     generate_signed_tests!(I1024, U1024, i1024);
     generate_signed_tests!(I1088, U1088, i1088);
     generate_signed_tests!(I1152, U1152, i1152);
+    generate_signed_tests!(I1280, U1280, i1280);
+    generate_signed_tests!(I1344, U1344, i1344);
     generate_signed_tests!(I1536, U1536, i1536);
     generate_signed_tests!(I1600, U1600, i1600);
     generate_signed_tests!(I1664, U1664, i1664);
@@ -175,15 +231,22 @@ mod tests {
     generate_signed_tests!(I15488, U15488, i15488);
   }
   mod sigconversion {
+    generate_sigconversion_tests!(I192, U192, i192);
     generate_sigconversion_tests!(I256, U256, i256);
     generate_sigconversion_tests!(I320, U320, i320);
     generate_sigconversion_tests!(I384, U384, i384);
+    generate_sigconversion_tests!(I448, U448, i448);
     generate_sigconversion_tests!(I512, U512, i512);
     generate_sigconversion_tests!(I576, U576, i576);
     generate_sigconversion_tests!(I640, U640, i640);
+    generate_sigconversion_tests!(I704, U704, i704);
+    generate_sigconversion_tests!(I896, U896, i896);
+    generate_sigconversion_tests!(I960, U960, i960);
     generate_sigconversion_tests!(I1024, U1024, i1024);
     generate_sigconversion_tests!(I1088, U1088, i1088);
     generate_sigconversion_tests!(I1152, U1152, i1152);
+    generate_sigconversion_tests!(I1280, U1280, i1280);
+    generate_sigconversion_tests!(I1344, U1344, i1344);
     generate_sigconversion_tests!(I1536, U1536, i1536);
     generate_sigconversion_tests!(I1600, U1600, i1600);
     generate_sigconversion_tests!(I1664, U1664, i1664);
@@ -210,6 +273,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_sigcmp_tests!(I256, U256, i256);
     generate_sigcmp_tests!(I320, U320, i320);
     generate_sigcmp_tests!(I576, U576, i576);
     generate_sigcmp_tests!(I1088, U1088, i1088);
@@ -221,10 +285,29 @@ mod tests {
     generate_sigcmp_tests!(I8256, U8256, i8256);
     generate_sigcmp_tests!(I15424, U15424, i15424);
   }
+  mod sigmul {
+    use super::super::*;
+    use testing::{build_test_path,run_test};
+
+    generate_sigmul_tests!(I256, U256, i256, I512, U512);
+    generate_sigmul_tests!(I320, U320, i320, I640, U640);
+    generate_sigmul_tests!(I448, U448, i448, I896, U896);
+    generate_sigmul_tests!(I640, U640, i640, I1280, U1280);
+  }
+  mod sigdiv {
+    use super::super::*;
+    use testing::{build_test_path,run_test};
+
+    generate_sigdiv_tests!(I512, U512, i512);
+    generate_sigdiv_tests!(I640, U640, i640);
+    generate_sigdiv_tests!(I896, U896, i896);
+    generate_sigdiv_tests!(I1280, U1280, i1280);
+  }
   mod sigshiftl {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_sigshiftl_tests!(I256, U256, i256);
     generate_sigshiftl_tests!(I320, U320, i320);
     generate_sigshiftl_tests!(I576, U576, i576);
     generate_sigshiftl_tests!(I1088, U1088, i1088);
@@ -240,6 +323,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_sigshiftr_tests!(I256, U256, i256);
     generate_sigshiftr_tests!(I320, U320, i320);
     generate_sigshiftr_tests!(I576, U576, i576);
     generate_sigshiftr_tests!(I1088, U1088, i1088);
@@ -255,6 +339,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_egcd_tests!(I192, U192, i192, I256, U256);
     generate_egcd_tests!(I256, U256, i256, I320, U320);
     generate_egcd_tests!(I512, U512, i512, I576, U576);
     generate_egcd_tests!(ignore I1024, U1024, i1024, I1088, U1088);
@@ -270,6 +355,8 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_modinv_tests!(I192, U192, i192);
+    generate_modinv_tests!(I256, U256, i256);
     generate_modinv_tests!(I512, U512, i512);
     generate_modinv_tests!(I1024, U1024, i1024);
     generate_modinv_tests!(ignore I2048, U2048, i2048);

src/signed/mod.rs

@@ -18,10 +18,14 @@ mod compare;
 #[macro_use]
 mod conversion;
 #[macro_use]
+mod div;
+#[macro_use]
 mod egcd;
 #[macro_use]
 mod modinv;
 #[macro_use]
+mod mul;
+#[macro_use]
 mod shift;
 #[macro_use]
 mod subtraction;
@@ -31,6 +35,9 @@ use quickcheck::{Arbitrary,Gen};
 use std::cmp::{Ord,Ordering,PartialOrd};
 use std::fmt;
 use std::ops::{Add,AddAssign};
+use std::ops::{Div,DivAssign};
+use std::ops::{Mul,MulAssign};
+use std::ops::{Rem,RemAssign};
 use std::ops::{Shl,ShlAssign,Shr,ShrAssign};
 use std::ops::{Sub,SubAssign};
 use unsigned::*;

src/signed/mul.rs

@@ -0,0 +1,90 @@
+macro_rules! mul_impls
+{
+    ($name: ident, $dbl: ident) => {
+        impl MulAssign<$name> for $name {
+            fn mul_assign(&mut self, rhs: $name) {
+                self.mul_assign(&rhs);
+            }
+        }
+
+        impl<'a> MulAssign<&'a $name> for $name {
+            fn mul_assign(&mut self, rhs: &$name) {
+                self.value *= &rhs.value;
+                self.negative = !self.value.is_zero() && (self.negative != rhs.negative);
+            }
+        }
+
+        impl Mul<$name> for $name {
+            type Output = $dbl;
+
+            fn mul(self, rhs: $name) -> $dbl
+            {
+                &self * &rhs
+            }
+        }
+
+        impl<'a> Mul<&'a $name> for $name {
+            type Output = $dbl;
+
+            fn mul(self, rhs: &$name) -> $dbl
+            {
+                &self * rhs
+            }
+        }
+
+        impl<'a> Mul<$name> for &'a $name {
+            type Output = $dbl;
+
+            fn mul(self, rhs: $name) -> $dbl
+            {
+                self * &rhs
+            }
+        }
+
+        impl<'a,'b> Mul<&'a $name> for &'b $name {
+            type Output = $dbl;
+
+            fn mul(self, rhs: &$name) -> $dbl
+            {
+                let outval = &self.value * &rhs.value;
+                let zero = outval.is_zero();
+                $dbl {
+                    value: outval,
+                    negative: !zero && (self.negative != rhs.negative)
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+macro_rules! generate_sigmul_tests {
+    ($sname: ident, $name: ident, $lname: ident, $dbl: ident, $udbl: ident) => {
+        #[test]
+        fn $lname() {
+            generate_sigmul_tests!(body $sname, $name, $dbl, $udbl);
+        }
+    };
+    (ignore $sname: ident, $name: ident, $lname: ident, $dbl: ident, $udbl: ident) => {
+        #[test]
+        #[ignore]
+        fn $lname() {
+            generate_sigmul_tests!(body $sname, $name, $dbl, $udbl);
+        }
+    };
+    (body $sname: ident, $name: ident, $dbl: ident, $udbl: ident) => {
+        let fname = build_test_path("sigmul", stringify!($sname));
+        run_test(fname.to_string(), 3, |case| {
+            let (nega, abytes) = case.get("a").unwrap();
+            let (negb, bbytes) = case.get("b").unwrap();
+            let (negc, cbytes) = case.get("c").unwrap();
+
+            let mut a = $sname::new(*nega, $name::from_bytes(abytes));
+            let     b = $sname::new(*negb, $name::from_bytes(bbytes));
+            let     c = $dbl::new(*negc, $udbl::from_bytes(cbytes));
+            assert_eq!(c, &a * &b, "base mul");
+            a *= b;
+            assert_eq!($sname::from(c), a, "in-place mul");
+        });
+    };
+}

src/unsigned/invoc.rs

@@ -1,13 +1,25 @@
 addition_impls!(U192, U256);
 base_impls!(U192, 3);
 random_impls!(U192, UniformU192);
+barrett_impl!(BarrettU192, U192, U256, U384, U448);
+div_impls!(U192, U384);
+modexp_impls!(U192, U192);
+modexp_impls!(U192, BarrettU192);
+modmul_impls!(U192, U384, BarrettU192);
+modsq_impls!(U192, U384, BarrettU192);
 multiply_impls!(U192, U384);
 shift_impls!(U192, 3);
+square_impls!(U192, U384, 192);
 subtraction_impls!(U192, 3);
 conversion_impls!(U192, U256);
+conversion_impls!(U192, U320);
 conversion_impls!(U192, U384);
+conversion_impls!(U192, U448);
+conversion_impls!(U192, U512);
+conversion_impls!(U192, U896);
 conversion_impls!(U192, U1024);
 sqrt_impls!(U192);
+prime_gen_impls!(U192);
 addition_impls!(U256, U320);
 base_impls!(U256, 4);
 random_impls!(U256, UniformU256);
@@ -22,8 +34,12 @@ shift_impls!(U256, 4);
 square_impls!(U256, U512, 256);
 subtraction_impls!(U256, 4);
 conversion_impls!(U256, U320);
+conversion_impls!(U256, U384);
+conversion_impls!(U256, U448);
 conversion_impls!(U256, U512);
 conversion_impls!(U256, U576);
+conversion_impls!(U256, U640);
+conversion_impls!(U256, U1152);
 conversion_impls!(U256, U2048);
 conversion_impls!(U256, U3072);
 sqrt_impls!(U256);
@@ -41,12 +57,23 @@ conversion_impls!(U320, U640);
 addition_impls!(U384, U448);
 base_impls!(U384, 6);
 random_impls!(U384, UniformU384);
+div_impls!(U384, U768);
 multiply_impls!(U384, U768);
+shift_impls!(U384, 6);
+subtraction_impls!(U384, 6);
 conversion_impls!(U384, U448);
 conversion_impls!(U384, U768);
+conversion_impls!(U384, U896);
+conversion_impls!(U384, U1024);
+addition_impls!(U448, U512);
 base_impls!(U448, 7);
 random_impls!(U448, UniformU448);
+div_impls!(U448, U896);
+multiply_impls!(U448, U896);
+subtraction_impls!(U448, 7);
 conversion_impls!(U448, U512);
+conversion_impls!(U448, U896);
+addition_impls!(U512, U576);
 base_impls!(U512, 8);
 random_impls!(U512, UniformU512);
 barrett_impl!(BarrettU512, U512, U576, U1024, U1088);
@@ -62,6 +89,8 @@ subtraction_impls!(U512, 8);
 conversion_impls!(U512, U576);
 conversion_impls!(U512, U1024);
 conversion_impls!(U512, U1088);
+conversion_impls!(U512, U2048);
+conversion_impls!(U512, U3072);
 prime_gen_impls!(U512);
 addition_impls!(U576, U640);
 base_impls!(U576, 9);
@@ -74,11 +103,33 @@ conversion_impls!(U576, U640);
 conversion_impls!(U576, U1024);
 conversion_impls!(U576, U1088);
 conversion_impls!(U576, U1152);
+conversion_impls!(U576, U1280);
+addition_impls!(U640, U704);
 base_impls!(U640, 10);
 random_impls!(U640, UniformU640);
+div_impls!(U640, U1280);
+multiply_impls!(U640, U1280);
 shift_impls!(U640, 10);
+subtraction_impls!(U640, 10);
+conversion_impls!(U640, U704);
+conversion_impls!(U640, U1280);
+base_impls!(U704, 11);
+random_impls!(U704, UniformU704);
+subtraction_impls!(U704, 11);
 base_impls!(U768, 12);
 random_impls!(U768, UniformU768);
+subtraction_impls!(U768, 12);
+addition_impls!(U896, U960);
+base_impls!(U896, 14);
+random_impls!(U896, UniformU896);
+div_impls!(U896, U1792);
+multiply_impls!(U896, U1792);
+subtraction_impls!(U896, 14);
+conversion_impls!(U896, U960);
+conversion_impls!(U896, U1792);
+base_impls!(U960, 15);
+random_impls!(U960, UniformU960);
+subtraction_impls!(U960, 15);
 addition_impls!(U1024, U1088);
 base_impls!(U1024, 16);
 random_impls!(U1024, UniformU1024);
@@ -93,8 +144,10 @@ shift_impls!(U1024, 16);
 square_impls!(U1024, U2048, 1024);
 subtraction_impls!(U1024, 16);
 conversion_impls!(U1024, U1088);
+conversion_impls!(U1024, U1152);
 conversion_impls!(U1024, U2048);
 conversion_impls!(U1024, U2112);
+conversion_impls!(U1024, U4224);
 sqrt_impls!(U1024);
 prime_gen_impls!(U1024);
 addition_impls!(U1088, U1152);
@@ -110,8 +163,22 @@ conversion_impls!(U1088, U2112);
 conversion_impls!(U1088, U2176);
 base_impls!(U1152, 18);
 random_impls!(U1152, UniformU1152);
+div_impls!(U1152, U2304);
+multiply_impls!(U1152, U2304);
 shift_impls!(U1152, 18);
 subtraction_impls!(U1152, 18);
+conversion_impls!(U1152, U2304);
+addition_impls!(U1280, U1344);
+base_impls!(U1280, 20);
+random_impls!(U1280, UniformU1280);
+div_impls!(U1280, U2560);
+multiply_impls!(U1280, U2560);
+subtraction_impls!(U1280, 20);
+conversion_impls!(U1280, U1344);
+conversion_impls!(U1280, U2560);
+base_impls!(U1344, 21);
+random_impls!(U1344, UniformU1344);
+subtraction_impls!(U1344, 21);
 base_impls!(U1536, 24);
 random_impls!(U1536, UniformU1536);
 barrett_impl!(BarrettU1536, U1536, U1600, U3072, U3136);
@@ -140,6 +207,10 @@ conversion_impls!(U1600, U3136);
 conversion_impls!(U1600, U3200);
 base_impls!(U1664, 26);
 random_impls!(U1664, UniformU1664);
+subtraction_impls!(U1664, 26);
+base_impls!(U1792, 28);
+random_impls!(U1792, UniformU1792);
+subtraction_impls!(U1792, 28);
 addition_impls!(U2048, U2112);
 base_impls!(U2048, 32);
 random_impls!(U2048, UniformU2048);
@@ -154,8 +225,10 @@ shift_impls!(U2048, 32);
 square_impls!(U2048, U4096, 2048);
 subtraction_impls!(U2048, 32);
 conversion_impls!(U2048, U2112);
+conversion_impls!(U2048, U2176);
 conversion_impls!(U2048, U4096);
 conversion_impls!(U2048, U4160);
+conversion_impls!(U2048, U8320);
 sqrt_impls!(U2048);
 prime_gen_impls!(U2048);
 addition_impls!(U2112, U2176);
@@ -173,6 +246,12 @@ base_impls!(U2176, 34);
 random_impls!(U2176, UniformU2176);
 shift_impls!(U2176, 34);
 subtraction_impls!(U2176, 34);
+base_impls!(U2304, 36);
+random_impls!(U2304, UniformU2304);
+subtraction_impls!(U2304, 36);
+base_impls!(U2560, 40);
+random_impls!(U2560, UniformU2560);
+subtraction_impls!(U2560, 40);
 addition_impls!(U3072, U3136);
 base_impls!(U3072, 48);
 random_impls!(U3072, UniformU3072);
@@ -187,9 +266,12 @@ shift_impls!(U3072, 48);
 square_impls!(U3072, U6144, 3072);
 subtraction_impls!(U3072, 48);
 conversion_impls!(U3072, U3136);
+conversion_impls!(U3072, U3200);
 conversion_impls!(U3072, U6144);
 conversion_impls!(U3072, U6208);
+conversion_impls!(U3072, U12416);
 sqrt_impls!(U3072);
+prime_gen_impls!(U3072);
 addition_impls!(U3136, U3200);
 base_impls!(U3136, 49);
 random_impls!(U3136, UniformU3136);
@@ -204,6 +286,8 @@ conversion_impls!(U3136, U6272);
 base_impls!(U3200, 50);
 random_impls!(U3200, UniformU3200);
 shift_impls!(U3200, 50);
+subtraction_impls!(U3200, 50);
+addition_impls!(U4096, U4160);
 base_impls!(U4096, 64);
 random_impls!(U4096, UniformU4096);
 barrett_impl!(BarrettU4096, U4096, U4160, U8192, U8256);
@@ -233,8 +317,12 @@ conversion_impls!(U4160, U8256);
 conversion_impls!(U4160, U8320);
 base_impls!(U4224, 66);
 random_impls!(U4224, UniformU4224);
+div_impls!(U4224, U8448);
+multiply_impls!(U4224, U8448);
 shift_impls!(U4224, 66);
 subtraction_impls!(U4224, 66);
+conversion_impls!(U4224, U8448);
+addition_impls!(U6144, U6208);
 base_impls!(U6144, 96);
 random_impls!(U6144, UniformU6144);
 div_impls!(U6144, U12288);
@@ -283,6 +371,7 @@ conversion_impls!(U7744, U15424);
 conversion_impls!(U7744, U15488);
 base_impls!(U7808, 122);
 random_impls!(U7808, UniformU7808);
+subtraction_impls!(U7808, 122);
 base_impls!(U8192, 128);
 random_impls!(U8192, UniformU8192);
 barrett_impl!(BarrettU8192, U8192, U8256, U16384, U16448);
@@ -311,14 +400,23 @@ conversion_impls!(U8256, U16448);
 conversion_impls!(U8256, U16512);
 base_impls!(U8320, 130);
 random_impls!(U8320, UniformU8320);
+div_impls!(U8320, U16640);
+multiply_impls!(U8320, U16640);
 shift_impls!(U8320, 130);
 subtraction_impls!(U8320, 130);
+conversion_impls!(U8320, U16640);
+base_impls!(U8448, 132);
+random_impls!(U8448, UniformU8448);
+subtraction_impls!(U8448, 132);
 base_impls!(U12288, 192);
 random_impls!(U12288, UniformU12288);
 subtraction_impls!(U12288, 192);
 base_impls!(U12416, 194);
 random_impls!(U12416, UniformU12416);
+div_impls!(U12416, U24832);
+multiply_impls!(U12416, U24832);
 subtraction_impls!(U12416, 194);
+conversion_impls!(U12416, U24832);
 base_impls!(U15360, 240);
 random_impls!(U15360, UniformU15360);
 barrett_impl!(BarrettU15360, U15360, U15424, U30720, U30784);
@@ -348,6 +446,7 @@ conversion_impls!(U15424, U30848);
 base_impls!(U15488, 242);
 random_impls!(U15488, UniformU15488);
 shift_impls!(U15488, 242);
+subtraction_impls!(U15488, 242);
 base_impls!(U16384, 256);
 random_impls!(U16384, UniformU16384);
 div_impls!(U16384, U32768);
@@ -368,6 +467,12 @@ base_impls!(U16512, 258);
 random_impls!(U16512, UniformU16512);
 shift_impls!(U16512, 258);
 subtraction_impls!(U16512, 258);
+base_impls!(U16640, 260);
+random_impls!(U16640, UniformU16640);
+subtraction_impls!(U16640, 260);
+base_impls!(U24832, 388);
+random_impls!(U24832, UniformU24832);
+subtraction_impls!(U24832, 388);
 base_impls!(U30720, 480);
 random_impls!(U30720, UniformU30720);
 div_impls!(U30720, U61440);
@@ -416,16 +521,24 @@ mod tests {
     generate_base_tests!(U512, u512);
     generate_base_tests!(U576, u576);
     generate_base_tests!(U640, u640);
+    generate_base_tests!(U704, u704);
     generate_base_tests!(U768, u768);
+    generate_base_tests!(U896, u896);
+    generate_base_tests!(U960, u960);
     generate_base_tests!(U1024, u1024);
     generate_base_tests!(U1088, u1088);
     generate_base_tests!(U1152, u1152);
+    generate_base_tests!(U1280, u1280);
+    generate_base_tests!(U1344, u1344);
     generate_base_tests!(U1536, u1536);
     generate_base_tests!(U1600, u1600);
     generate_base_tests!(U1664, u1664);
+    generate_base_tests!(U1792, u1792);
     generate_base_tests!(U2048, u2048);
     generate_base_tests!(U2112, u2112);
     generate_base_tests!(U2176, u2176);
+    generate_base_tests!(U2304, u2304);
+    generate_base_tests!(U2560, u2560);
     generate_base_tests!(U3072, u3072);
     generate_base_tests!(U3136, u3136);
     generate_base_tests!(U3200, u3200);
@@ -441,6 +554,7 @@ mod tests {
     generate_base_tests!(U8192, u8192);
     generate_base_tests!(U8256, u8256);
     generate_base_tests!(U8320, u8320);
+    generate_base_tests!(U8448, u8448);
     generate_base_tests!(U12288, u12288);
     generate_base_tests!(U12416, u12416);
     generate_base_tests!(U15360, u15360);
@@ -449,6 +563,8 @@ mod tests {
     generate_base_tests!(ignore U16384, u16384);
     generate_base_tests!(ignore U16448, u16448);
     generate_base_tests!(ignore U16512, u16512);
+    generate_base_tests!(ignore U16640, u16640);
+    generate_base_tests!(ignore U24832, u24832);
     generate_base_tests!(ignore U30720, u30720);
     generate_base_tests!(ignore U30784, u30784);
     generate_base_tests!(ignore U30848, u30848);
@@ -466,16 +582,24 @@ mod tests {
     generate_conversion_tests!(U512, u512);
     generate_conversion_tests!(U576, u576);
     generate_conversion_tests!(U640, u640);
+    generate_conversion_tests!(U704, u704);
     generate_conversion_tests!(U768, u768);
+    generate_conversion_tests!(U896, u896);
+    generate_conversion_tests!(U960, u960);
     generate_conversion_tests!(U1024, u1024);
     generate_conversion_tests!(U1088, u1088);
     generate_conversion_tests!(U1152, u1152);
+    generate_conversion_tests!(U1280, u1280);
+    generate_conversion_tests!(U1344, u1344);
     generate_conversion_tests!(U1536, u1536);
     generate_conversion_tests!(U1600, u1600);
     generate_conversion_tests!(U1664, u1664);
+    generate_conversion_tests!(U1792, u1792);
     generate_conversion_tests!(U2048, u2048);
     generate_conversion_tests!(U2112, u2112);
     generate_conversion_tests!(U2176, u2176);
+    generate_conversion_tests!(U2304, u2304);
+    generate_conversion_tests!(U2560, u2560);
     generate_conversion_tests!(U3072, u3072);
     generate_conversion_tests!(U3136, u3136);
     generate_conversion_tests!(U3200, u3200);
@@ -491,6 +615,7 @@ mod tests {
     generate_conversion_tests!(U8192, u8192);
     generate_conversion_tests!(U8256, u8256);
     generate_conversion_tests!(U8320, u8320);
+    generate_conversion_tests!(U8448, u8448);
     generate_conversion_tests!(U12288, u12288);
     generate_conversion_tests!(U12416, u12416);
     generate_conversion_tests!(U15360, u15360);
@@ -499,6 +624,8 @@ mod tests {
     generate_conversion_tests!(U16384, u16384);
     generate_conversion_tests!(U16448, u16448);
     generate_conversion_tests!(U16512, u16512);
+    generate_conversion_tests!(U16640, u16640);
+    generate_conversion_tests!(U24832, u24832);
     generate_conversion_tests!(U30720, u30720);
     generate_conversion_tests!(U30784, u30784);
     generate_conversion_tests!(U30848, u30848);
@@ -516,16 +643,24 @@ mod tests {
     generate_codec_tests!(U512, u512);
     generate_codec_tests!(U576, u576);
     generate_codec_tests!(U640, u640);
+    generate_codec_tests!(U704, u704);
     generate_codec_tests!(U768, u768);
+    generate_codec_tests!(U896, u896);
+    generate_codec_tests!(U960, u960);
     generate_codec_tests!(U1024, u1024);
     generate_codec_tests!(U1088, u1088);
     generate_codec_tests!(U1152, u1152);
+    generate_codec_tests!(U1280, u1280);
+    generate_codec_tests!(U1344, u1344);
     generate_codec_tests!(U1536, u1536);
     generate_codec_tests!(U1600, u1600);
     generate_codec_tests!(U1664, u1664);
+    generate_codec_tests!(U1792, u1792);
     generate_codec_tests!(U2048, u2048);
     generate_codec_tests!(U2112, u2112);
     generate_codec_tests!(U2176, u2176);
+    generate_codec_tests!(U2304, u2304);
+    generate_codec_tests!(U2560, u2560);
     generate_codec_tests!(U3072, u3072);
     generate_codec_tests!(U3136, u3136);
     generate_codec_tests!(U3200, u3200);
@@ -541,6 +676,7 @@ mod tests {
     generate_codec_tests!(U8192, u8192);
     generate_codec_tests!(U8256, u8256);
     generate_codec_tests!(U8320, u8320);
+    generate_codec_tests!(U8448, u8448);
     generate_codec_tests!(U12288, u12288);
     generate_codec_tests!(U12416, u12416);
     generate_codec_tests!(U15360, u15360);
@@ -549,6 +685,8 @@ mod tests {
     generate_codec_tests!(U16384, u16384);
     generate_codec_tests!(U16448, u16448);
     generate_codec_tests!(U16512, u16512);
+    generate_codec_tests!(U16640, u16640);
+    generate_codec_tests!(U24832, u24832);
     generate_codec_tests!(U30720, u30720);
     generate_codec_tests!(U30784, u30784);
     generate_codec_tests!(U30848, u30848);
@@ -569,16 +707,24 @@ mod tests {
     generate_cmp_tests!(U512, u512);
     generate_cmp_tests!(U576, u576);
     generate_cmp_tests!(U640, u640);
+    generate_cmp_tests!(U704, u704);
     generate_cmp_tests!(U768, u768);
+    generate_cmp_tests!(U896, u896);
+    generate_cmp_tests!(U960, u960);
     generate_cmp_tests!(U1024, u1024);
     generate_cmp_tests!(U1088, u1088);
     generate_cmp_tests!(U1152, u1152);
+    generate_cmp_tests!(U1280, u1280);
+    generate_cmp_tests!(U1344, u1344);
     generate_cmp_tests!(U1536, u1536);
     generate_cmp_tests!(U1600, u1600);
     generate_cmp_tests!(U1664, u1664);
+    generate_cmp_tests!(U1792, u1792);
     generate_cmp_tests!(U2048, u2048);
     generate_cmp_tests!(U2112, u2112);
     generate_cmp_tests!(U2176, u2176);
+    generate_cmp_tests!(U2304, u2304);
+    generate_cmp_tests!(U2560, u2560);
     generate_cmp_tests!(U3072, u3072);
     generate_cmp_tests!(U3136, u3136);
     generate_cmp_tests!(U3200, u3200);
@@ -594,6 +740,7 @@ mod tests {
     generate_cmp_tests!(U8192, u8192);
     generate_cmp_tests!(U8256, u8256);
     generate_cmp_tests!(U8320, u8320);
+    generate_cmp_tests!(U8448, u8448);
     generate_cmp_tests!(U12288, u12288);
     generate_cmp_tests!(U12416, u12416);
     generate_cmp_tests!(U15360, u15360);
@@ -602,6 +749,8 @@ mod tests {
     generate_cmp_tests!(ignore U16384, u16384);
     generate_cmp_tests!(ignore U16448, u16448);
     generate_cmp_tests!(ignore U16512, u16512);
+    generate_cmp_tests!(ignore U16640, u16640);
+    generate_cmp_tests!(ignore U24832, u24832);
     generate_cmp_tests!(ignore U30720, u30720);
     generate_cmp_tests!(ignore U30784, u30784);
     generate_cmp_tests!(ignore U30848, u30848);
@@ -617,18 +766,32 @@ mod tests {
     generate_sub_tests!(U192, u192);
     generate_sub_tests!(U256, u256);
     generate_sub_tests!(U320, u320);
+    generate_sub_tests!(U384, u384);
+    generate_sub_tests!(U448, u448);
     generate_sub_tests!(U512, u512);
     generate_sub_tests!(U576, u576);
+    generate_sub_tests!(U640, u640);
+    generate_sub_tests!(U704, u704);
+    generate_sub_tests!(U768, u768);
+    generate_sub_tests!(U896, u896);
+    generate_sub_tests!(U960, u960);
     generate_sub_tests!(U1024, u1024);
     generate_sub_tests!(U1088, u1088);
     generate_sub_tests!(U1152, u1152);
+    generate_sub_tests!(U1280, u1280);
+    generate_sub_tests!(U1344, u1344);
     generate_sub_tests!(U1536, u1536);
     generate_sub_tests!(U1600, u1600);
+    generate_sub_tests!(U1664, u1664);
+    generate_sub_tests!(U1792, u1792);
     generate_sub_tests!(U2048, u2048);
     generate_sub_tests!(U2112, u2112);
     generate_sub_tests!(U2176, u2176);
+    generate_sub_tests!(U2304, u2304);
+    generate_sub_tests!(U2560, u2560);
     generate_sub_tests!(U3072, u3072);
     generate_sub_tests!(U3136, u3136);
+    generate_sub_tests!(U3200, u3200);
     generate_sub_tests!(U4096, u4096);
     generate_sub_tests!(U4160, u4160);
     generate_sub_tests!(U4224, u4224);
@@ -637,16 +800,21 @@ mod tests {
     generate_sub_tests!(U6272, u6272);
     generate_sub_tests!(U7680, u7680);
     generate_sub_tests!(U7744, u7744);
+    generate_sub_tests!(U7808, u7808);
     generate_sub_tests!(U8192, u8192);
     generate_sub_tests!(U8256, u8256);
     generate_sub_tests!(U8320, u8320);
+    generate_sub_tests!(U8448, u8448);
     generate_sub_tests!(ignore U12288, u12288);
     generate_sub_tests!(ignore U12416, u12416);
     generate_sub_tests!(ignore U15360, u15360);
     generate_sub_tests!(ignore U15424, u15424);
+    generate_sub_tests!(ignore U15488, u15488);
     generate_sub_tests!(ignore U16384, u16384);
     generate_sub_tests!(ignore U16448, u16448);
     generate_sub_tests!(ignore U16512, u16512);
+    generate_sub_tests!(ignore U16640, u16640);
+    generate_sub_tests!(ignore U24832, u24832);
     generate_sub_tests!(ignore U30720, u30720);
     generate_sub_tests!(ignore U30784, u30784);
     generate_sub_tests!(ignore U30848, u30848);
@@ -662,6 +830,7 @@ mod tests {
     generate_shiftl_tests!(U192, u192);
     generate_shiftl_tests!(U256, u256);
     generate_shiftl_tests!(U320, u320);
+    generate_shiftl_tests!(U384, u384);
     generate_shiftl_tests!(U512, u512);
     generate_shiftl_tests!(U576, u576);
     generate_shiftl_tests!(U640, u640);
@@ -701,6 +870,7 @@ mod tests {
     generate_shiftr_tests!(U192, u192);
     generate_shiftr_tests!(U256, u256);
     generate_shiftr_tests!(U320, u320);
+    generate_shiftr_tests!(U384, u384);
     generate_shiftr_tests!(U512, u512);
     generate_shiftr_tests!(U576, u576);
     generate_shiftr_tests!(U640, u640);
@@ -741,15 +911,22 @@ mod tests {
     generate_add_tests!(U256, u256, U320);
     generate_add_tests!(U320, u320, U384);
     generate_add_tests!(U384, u384, U448);
+    generate_add_tests!(U448, u448, U512);
+    generate_add_tests!(U512, u512, U576);
     generate_add_tests!(U576, u576, U640);
+    generate_add_tests!(U640, u640, U704);
+    generate_add_tests!(U896, u896, U960);
     generate_add_tests!(U1024, u1024, U1088);
     generate_add_tests!(U1088, u1088, U1152);
+    generate_add_tests!(U1280, u1280, U1344);
     generate_add_tests!(U1600, u1600, U1664);
     generate_add_tests!(U2048, u2048, U2112);
     generate_add_tests!(U2112, u2112, U2176);
     generate_add_tests!(U3072, u3072, U3136);
     generate_add_tests!(U3136, u3136, U3200);
+    generate_add_tests!(U4096, u4096, U4160);
     generate_add_tests!(U4160, u4160, U4224);
+    generate_add_tests!(U6144, u6144, U6208);
     generate_add_tests!(U6208, u6208, U6272);
     generate_add_tests!(U7744, u7744, U7808);
     generate_add_tests!(U8256, u8256, U8320);
@@ -765,10 +942,15 @@ mod tests {
     generate_mul_tests!(U256, u256, U512);
     generate_mul_tests!(U320, u320, U640);
     generate_mul_tests!(U384, u384, U768);
+    generate_mul_tests!(U448, u448, U896);
     generate_mul_tests!(U512, u512, U1024);
     generate_mul_tests!(U576, u576, U1152);
+    generate_mul_tests!(U640, u640, U1280);
+    generate_mul_tests!(U896, u896, U1792);
     generate_mul_tests!(U1024, u1024, U2048);
     generate_mul_tests!(U1088, u1088, U2176);
+    generate_mul_tests!(U1152, u1152, U2304);
+    generate_mul_tests!(U1280, u1280, U2560);
     generate_mul_tests!(U1536, u1536, U3072);
     generate_mul_tests!(U1600, u1600, U3200);
     generate_mul_tests!(U2048, u2048, U4096);
@@ -777,12 +959,15 @@ mod tests {
     generate_mul_tests!(U3136, u3136, U6272);
     generate_mul_tests!(U4096, u4096, U8192);
     generate_mul_tests!(U4160, u4160, U8320);
+    generate_mul_tests!(U4224, u4224, U8448);
     generate_mul_tests!(U6144, u6144, U12288);
     generate_mul_tests!(U6208, u6208, U12416);
     generate_mul_tests!(U7680, u7680, U15360);
     generate_mul_tests!(U7744, u7744, U15488);
     generate_mul_tests!(U8192, u8192, U16384);
     generate_mul_tests!(U8256, u8256, U16512);
+    generate_mul_tests!(U8320, u8320, U16640);
+    generate_mul_tests!(ignore U12416, u12416, U24832);
     generate_mul_tests!(ignore U15360, u15360, U30720);
     generate_mul_tests!(ignore U15424, u15424, U30848);
     generate_mul_tests!(ignore U16384, u16384, U32768);
@@ -794,11 +979,18 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_div_tests!(U192, u192);
     generate_div_tests!(U256, u256);
+    generate_div_tests!(U384, u384);
+    generate_div_tests!(U448, u448);
     generate_div_tests!(U512, u512);
     generate_div_tests!(U576, u576);
+    generate_div_tests!(U640, u640);
+    generate_div_tests!(U896, u896);
     generate_div_tests!(U1024, u1024);
     generate_div_tests!(U1088, u1088);
+    generate_div_tests!(U1152, u1152);
+    generate_div_tests!(U1280, u1280);
     generate_div_tests!(U1536, u1536);
     generate_div_tests!(U2048, u2048);
     generate_div_tests!(ignore U2112, u2112);
@@ -806,11 +998,14 @@ mod tests {
     generate_div_tests!(ignore U3136, u3136);
     generate_div_tests!(ignore U4096, u4096);
     generate_div_tests!(ignore U4160, u4160);
+    generate_div_tests!(ignore U4224, u4224);
     generate_div_tests!(ignore U6144, u6144);
     generate_div_tests!(ignore U6208, u6208);
     generate_div_tests!(ignore U7680, u7680);
     generate_div_tests!(ignore U8192, u8192);
     generate_div_tests!(ignore U8256, u8256);
+    generate_div_tests!(ignore U8320, u8320);
+    generate_div_tests!(ignore U12416, u12416);
     generate_div_tests!(ignore U15360, u15360);
     generate_div_tests!(ignore U15424, u15424);
     generate_div_tests!(ignore U16384, u16384);
@@ -822,6 +1017,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_barrett_gen_tests!(U192, u192, U256);
     generate_barrett_gen_tests!(U256, u256, U320);
     generate_barrett_gen_tests!(U512, u512, U576);
     generate_barrett_gen_tests!(U1024, u1024, U1088);
@@ -837,6 +1033,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_barrett_red_tests!(U192, u192, U256, U384);
     generate_barrett_red_tests!(U256, u256, U320, U512);
     generate_barrett_red_tests!(U512, u512, U576, U1024);
     generate_barrett_red_tests!(U1024, u1024, U1088, U2048);
@@ -852,6 +1049,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_modsq_tests!(U192, u192);
     generate_modsq_tests!(U256, u256);
     generate_modsq_tests!(U512, u512);
     generate_modsq_tests!(U1024, u1024);
@@ -867,6 +1065,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_modmul_tests!(U192, u192);
     generate_modmul_tests!(U256, u256);
     generate_modmul_tests!(U512, u512);
     generate_modmul_tests!(U1024, u1024);
@@ -882,6 +1081,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_modexp_tests!(U192, u192);
     generate_modexp_tests!(U256, u256);
     generate_modexp_tests!(ignore U512, u512);
     generate_modexp_tests!(ignore U1024, u1024);
@@ -897,6 +1097,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_square_tests!(U192, u192, U384);
     generate_square_tests!(U256, u256, U512);
     generate_square_tests!(U512, u512, U1024);
     generate_square_tests!(U1024, u1024, U2048);
@@ -922,6 +1123,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_barrett_modsq_tests!(U192, u192, U256);
     generate_barrett_modsq_tests!(U256, u256, U320);
     generate_barrett_modsq_tests!(U512, u512, U576);
     generate_barrett_modsq_tests!(U1024, u1024, U1088);
@@ -937,6 +1139,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_barrett_modmul_tests!(U192, u192, U256);
     generate_barrett_modmul_tests!(U256, u256, U320);
     generate_barrett_modmul_tests!(U512, u512, U576);
     generate_barrett_modmul_tests!(U1024, u1024, U1088);
@@ -952,6 +1155,7 @@ mod tests {
     use super::super::*;
     use testing::{build_test_path,run_test};
 
+    generate_barrett_modexp_tests!(U192, u192, U256);
     generate_barrett_modexp_tests!(U256, u256, U320);
     generate_barrett_modexp_tests!(U512, u512, U576);
     generate_barrett_modexp_tests!(ignore U1024, u1024, U1088);

test-generator/Invocs.hs

@@ -99,6 +99,8 @@ main = do
            SignedCmp    -> hPutStrLn hndl ("cmp_impls!(I" ++ show size ++ ");")
            SignedShift  -> hPutStrLn hndl ("shift_impls!(I" ++ show size ++ ", U" ++ show size ++ ");")
            SignedSub    -> hPutStrLn hndl ("subtraction_impls!(I" ++ show size ++ ", I" ++ show (size + 64) ++ ", U" ++ show (size + 64) ++ ");")
+           SignedMul    -> hPutStrLn hndl ("mul_impls!(I" ++ show size ++ ", I" ++ show (size * 2) ++ ");")
+           SignedDiv    -> hPutStrLn hndl ("div_impls!(I" ++ show size ++ ", U" ++ show size ++ ");")
            EGCD         -> hPutStrLn hndl ("egcd_impls!(I" ++ show (size + 64) ++ ", U" ++ show size ++ ", I" ++ show size ++ ");")
            ModInv       -> hPutStrLn hndl ("modinv_impls!(U" ++ show size ++ ", I" ++ show (size + 64) ++ ", U" ++ show (size + 64) ++ ");")
            SigConvert v -> hPutStrLn hndl ("conversion_impls!(I" ++ show size ++ ", U" ++ show size ++ ", I" ++ show v ++ ", U" ++ show v ++ ");")
@@ -111,6 +113,8 @@ main = do
        generateSigTestBlock hndl "signed"        SignedBase  True  90000 []       []
        generateSigTestBlock hndl "sigconversion" SignedBase  False 90000 []       []
        generateSigTestBlock hndl "sigcmp"        SignedCmp   True  90000 []       []
+       generateSigTestBlock hndl "sigmul"        SignedMul   True  9000  [(* 2)]  [(* 2)]
+       generateSigTestBlock hndl "sigdiv"        SignedDiv   True  2049  []       []
        generateSigTestBlock hndl "sigshiftl"     SignedShift True  16384 []       []
        generateSigTestBlock hndl "sigshiftr"     SignedShift True  16384 []       []
        generateSigTestBlock hndl "egcd"          EGCD        True  1024  [(+ 64)] [(+ 64)]

test-generator/Requirements.hs

@@ -24,6 +24,8 @@ data Operation = Add
                | SignedCmp
                | SignedShift
                | SignedSub
+               | SignedMul
+               | SignedDiv
                | SigConvert Int
                | SquareRoot
                | EGCD
@@ -31,6 +33,7 @@ data Operation = Add
                | PrimeGen
                | RSA
                | DSA
+               | ECDSA
  deriving (Eq, Ord, Show)
 
 data Requirement = Req Int Operation
@@ -49,7 +52,24 @@ needs = [ Need RSA         (\ size -> [Req (size `div` 2) Sub,
         , Need DSA         (\ size -> [Req size BaseOps,
                                        Req size Shifts,
                                        Req size Add,
-                                       Req size SquareRoot])
+                                       Req size SquareRoot,
+                                       Req size PrimeGen,
+                                       Req size ModInv,
+                                       Req size Mul,
+                                       Req (size * 2) Add,
+                                       Req (((size * 2) + 64) * 2) Div,
+                                       Req size (Convert 512),
+                                       Req size (Convert (size + 128)),
+                                       Req size (Convert ((size * 2) + 64)),
+                                       Req size (Convert (((size * 2) + 64) * 2))
+                                       ])
+        , Need ECDSA       (\ size -> [Req size SignedSub,
+                                       Req (size + 64) SignedMul,
+                                       Req ((size + 64) * 2) SignedSub,
+                                       Req ((size + 64) * 2) SignedDiv,
+                                       Req size (Convert ((size + 64) * 2)),
+                                       Req size (SigConvert ((size + 64) * 2))
+                                       ])
         , Need PrimeGen    (\ size -> [Req size Div,
                                        Req size Shifts,
                                        Req size ModExp,
@@ -131,9 +151,16 @@ needs = [ Need RSA         (\ size -> [Req (size `div` 2) Sub,
                                        Req (size + 64) BaseOps,
                                        Req size Add,
                                        Req size Sub,
+                                       Req (size + 64) Sub,
                                        Req size (Convert (size + 64)),
                                        Req size (SigConvert (size + 64))
                                       ])
+        , Need SignedMul   (\ size -> [Req size Mul,
+                                       Req (size * 2) SignedBase,
+                                       Req size (SigConvert (size * 2))
+                                      ])
+        , Need SignedDiv   (\ size -> [Req size Div
+                                      ])
         , Need EGCD        (\ size -> [Req size SignedBase,
                                        Req size BaseOps,
                                        Req (size + 64) SignedBase,
@@ -170,10 +197,15 @@ rsaSizes =  [512,1024,2048,3072,4096,8192,15360]
 dsaSizes :: [Int]
 dsaSizes =  [192,256,1024,2048,3072]
 
+ecdsaSizes :: [Int]
+ecdsaSizes = [192,256,384,576]
+
 baseRequirements :: [Requirement]
 baseRequirements = concatMap (\ x -> [Req x RSA]) rsaSizes
                 ++ concatMap (\ x -> [Req x DSA]) dsaSizes
+                ++ concatMap (\ x -> [Req x ECDSA]) ecdsaSizes
                 ++ [Req 192 (Convert 1024), Req 256 (Convert 2048), Req 256 (Convert 3072)] -- used in DSA
+                ++ [Req 384 (Convert 1024), Req 512 (Convert 2048), Req 512 (Convert 3072)] -- used in DSA
                 ++ [Req 192 Add, Req 256 Add, Req 384 Add] -- used for testing
                 ++ [Req 192 Mul, Req 384 Mul] -- used for testing
                 ++ [Req 448 (Convert 512)] -- used for testing
@@ -182,16 +214,19 @@ requirements :: [Requirement]
 requirements = go baseRequirements
  where
   step ls = let news  = concatMap newRequirements ls
-                destBits = concatMap destRequirements (news ++ ls)
+                ls'   = concatMap sanitizeConverts (news ++ ls)
-            in ls ++ news ++ destBits
+                ls''  = removeDups (sort ls')
+            in ls''
   --
-  go ls = let ls' = removeDups (sort (step ls))
+  go ls = let ls' = step ls
           in if ls == ls' then ls else go ls'
   --
   removeDups [] = []
   removeDups (x:xs) | x `elem` xs = removeDups xs
                     | otherwise   = x : removeDups xs
   --
-  destRequirements (Req _ (Convert t)) = [Req t BaseOps]
+  sanitizeConverts (Req x (Convert y))
-  destRequirements _                   = []
+    | x == y    = []
-
+    | x < y     = [Req x (Convert y), Req y BaseOps]
+    | otherwise = [Req y (Convert x), Req x BaseOps]
+  sanitizeConverts x = [x]

test-generator/Tests.hs

@@ -36,6 +36,8 @@ testDatabase = [
     (SignedAdd,   "sigadd",         "signed addition",         sigaddTest),
     (SignedBase,  "signed",         "signed base",             signedTest),
     (SignedCmp,   "sigcmp",         "signed compare",          sigcmpTest),
+    (SignedMul,   "sigmul",         "signed multiply",         sigmulTest),
+    (SignedDiv,   "sigdiv",         "signed division",         sigdivTest),
     (SignedShift, "sigshiftr",      "signed shift right",      sigshiftrTest),
     (SignedShift, "sigshiftl",      "signed shift left",       sigshiftlTest),
     (SignedSub,   "sigsub",         "signed subtraction",      sigsubTest),
@@ -244,6 +246,25 @@ sigcmpTest size memory0 =
                                    ("e", showB (a == b))]
   in (res, a, memory2)
 
+sigdivTest :: Test
+sigdivTest size memory0 =
+  let (a, memory1) = genSign (generateNum memory0 "a" size)
+      (b, memory2) = genSign (generateNum memory1 "b" size)
+      q            = a `div` b
+      r            = a `mod` b
+      res          = Map.fromList [("a", showX a), ("b", showX b),
+                                   ("q", showX q), ("r", showX r)]
+  in (res, q, memory2)
+
+sigmulTest :: Test
+sigmulTest size memory0 =
+  let (a, memory1) = genSign (generateNum memory0 "a" size)
+      (b, memory2) = genSign (generateNum memory1 "b" size)
+      c            = a * b
+      res          = Map.fromList [("a", showX a), ("b", showX b),
+                                   ("c", showX c)]
+  in (res, c, memory2)
+
 egcdTest :: Test
 egcdTest size memory0 =
   let (x, memory1) = generateNum memory0 "x" size

test-generator/test-generator.cabal

@@ -22,7 +22,7 @@ executable gen-invocs
   main-is:             Invocs.hs
   other-modules:       Requirements
   -- other-extensions:
-  build-depends:       base >=4.11 && < 4.12, ascii-progress, random
+  build-depends:       base >=4.11 && < 4.14, ascii-progress, random
   hs-source-dirs:      .
   default-language:    Haskell2010
   ghc-options:         -Wall -O2 -threaded -rtsopts -with-rtsopts=-N
@@ -31,7 +31,7 @@ executable gen-tests
   main-is:             Main.hs
   other-modules:       Database, Math, Requirements, Tests
   -- other-extensions:
-  build-depends:       base >=4.11 && < 4.12, ascii-progress, containers, directory, filepath, integer-gmp, random
+  build-depends:       base >=4.11 && < 4.14, ascii-progress, containers, directory, filepath, integer-gmp, random
   hs-source-dirs:      .
   default-language:    Haskell2010
   ghc-options:         -Wall -O2 -threaded -rtsopts -with-rtsopts=-N