Modular squaring support (slow, initially)

src/cryptonum/squaring.rs

@@ -1,3 +1,11 @@
+use cryptonum::{U192,U256,U384,U512,U576,U1024,U2048,U3072,U4096,U8192,U15360};
+use cryptonum::division::divmod;
+
+pub trait ModSquare<T=Self>
+{
+    fn modsq(&mut self, m: &T);
+}
+
 // This is algorithm 14.16 from "Handbook of Applied Cryptography".
 pub fn raw_square(x: &[u64], result: &mut [u64])
 {
@@ -44,48 +52,101 @@ pub fn raw_square(x: &[u64], result: &mut [u64])
     }
 }
 
-#[cfg(test)]
+macro_rules! generate_squarers {
-use testing::run_test;
+    ($type: ident, $size: expr) => {
-#[cfg(test)]
+        impl ModSquare for $type {
-use cryptonum::Decoder;
+            fn modsq(&mut self, m: &$type) {
-#[cfg(test)]
+                let mut sqres  = [0; $size/32];
-use cryptonum::encoding::raw_decoder;
+                raw_square(&self.values, &mut sqres);
-#[cfg(test)]
+                let mut widerm = [0; $size/32];
-use cryptonum::{U192,U256,U384,U512,U576,U1024,U2048,U3072,U4096,U8192,U15360};
+                for (idx,val) in m.values.iter().enumerate() { widerm[idx] = *val; }
-
+                let mut dead   = [0; $size/32];
-macro_rules! generate_tests {
+                let mut answer = [0; $size/32];
-    ($name: ident, $testname: ident) => (
+                divmod(&sqres, &widerm, &mut dead, &mut answer);
-        #[cfg(test)]
+                for i in 0..answer.len() {
-        #[test]
+                    if i < self.values.len() {
-        #[allow(non_snake_case)]
+                        self.values[i] = answer[i];
-        fn $testname() {
+                    } else {
-            let fname = format!("tests/math/squaring{}.test",
+                        assert_eq!(answer[i], 0);
-                                stringify!($name));
+                    }
-            run_test(fname.to_string(), 2, |case| {
+                }
-                let (neg0, abytes) = case.get("a").unwrap();
+            }
-                let (neg1, rbytes) = case.get("r").unwrap();
-
-                assert!(!neg0 && !neg1);
-                let a = $name::from_bytes(abytes);
-                let mut result = Vec::with_capacity(a.values.len() * 2);
-                result.resize(a.values.len() * 2, 0);
-                let mut myresult = result.clone();
-                raw_decoder(rbytes, &mut result);
-                raw_square(&a.values, &mut myresult);
-                assert_eq!(result, myresult);
-            });
         }
-    )
+    };
 }
 
-generate_tests!(U192,u192);
+generate_squarers!(U192,     192);
-generate_tests!(U256,u256);
+generate_squarers!(U256,     256);
-generate_tests!(U384,u384);
+generate_squarers!(U384,     384);
-generate_tests!(U512,u512);
+generate_squarers!(U512,     512);
-generate_tests!(U576,u576);
+generate_squarers!(U576,     576);
-generate_tests!(U1024,u1024);
+generate_squarers!(U1024,   1024);
-generate_tests!(U2048,u2048);
+generate_squarers!(U2048,   2048);
-generate_tests!(U3072,u3072);
+generate_squarers!(U3072,   3072);
-generate_tests!(U4096,u4096);
+generate_squarers!(U4096,   4096);
-generate_tests!(U8192,u8192);
+generate_squarers!(U8192,   8192);
-generate_tests!(U15360,u15360);
+generate_squarers!(U15360, 15360);
+
+macro_rules! generate_tests {
+    ( $( $name:ident ),* ) => {
+        #[cfg(test)]
+        mod normal {
+            use cryptonum::Decoder;
+            use cryptonum::encoding::raw_decoder;
+            use super::*;
+            use testing::run_test;
+
+            $(
+                #[test]
+                #[allow(non_snake_case)]
+                fn $name() {
+                    let fname = format!("tests/math/squaring{}.test",
+                                        stringify!($name));
+                    run_test(fname.to_string(), 2, |case| {
+                        let (neg0, abytes) = case.get("a").unwrap();
+                        let (neg1, rbytes) = case.get("r").unwrap();
+
+                        assert!(!neg0 && !neg1);
+                        let a = $name::from_bytes(abytes);
+                        let mut result = Vec::with_capacity(a.values.len() * 2);
+                        result.resize(a.values.len() * 2, 0);
+                        let mut myresult = result.clone();
+                        raw_decoder(rbytes, &mut result);
+                        raw_square(&a.values, &mut myresult);
+                        assert_eq!(result, myresult);
+                    });
+                }
+            )*
+        }
+
+        #[cfg(test)]
+        mod slow_modular {
+            use cryptonum::Decoder;
+            use super::*;
+            use testing::run_test;
+
+            $(
+                #[test]
+                #[allow(non_snake_case)]
+                fn $name() {
+                    let fname = format!("tests/math/modsq{}.test",
+                                        stringify!($name));
+                    run_test(fname.to_string(), 3, |case| {
+                        let (neg0, abytes) = case.get("a").unwrap();
+                        let (neg1, mbytes) = case.get("m").unwrap();
+                        let (neg2, rbytes) = case.get("r").unwrap();
+
+                        assert!(!neg0 && !neg1 && !neg2);
+                        let mut a = $name::from_bytes(abytes);
+                        let     m = $name::from_bytes(mbytes);
+                        let     r = $name::from_bytes(rbytes);
+                        a.modsq(&m);
+                        assert_eq!(a, r);
+                    });
+                }
+            )*
+        }
+    }
+}
+
+generate_tests!(U192, U256, U384, U512, U576, U1024, U2048, U3072, U4096, U8192, U15360);

tests/math/GenerateTests.hs

@@ -15,6 +15,7 @@ testTypes = [("addition", addTest),
              ("expandingmul", expmulTest),
              ("modmul", modmulTest),
              ("squaring", squareTest),
+             ("modsq", modsqTest),
              ("division", divTest)
             ]
 
@@ -119,6 +120,18 @@ squareTest bitsize gen0 = (res, gen1)
   res       = Map.fromList [("a", showHex a' ""),
                             ("r", showHex r  "")]
 
+modsqTest :: Int -> StdGen -> (Map String String, StdGen)
+modsqTest bitsize gen0 = (res, gen1)
+ where
+  (a, gen1) = random gen0
+  (m, gen3) = random gen1
+  [a',m']   = splitMod bitsize [a,m]
+  r         = (a' * a') `mod` m'
+  res       = Map.fromList [("a", showHex a' ""),
+                            ("m", showHex m' ""),
+                            ("r", showHex r  "")]
+
+
 divTest :: Int -> StdGen -> (Map String String, StdGen)
 divTest bitsize gen0 = (res, gen2)
  where