introducing new tests for Montgomery-reduction based functions

diff --git a/host/bigint_test.rb b/host/bigint_test.rb
index 835cd4b57ae532e65bf4fe142671c5d725a9a667..90c46b39421fef1d8d4bbe0305095fdb0d76b333 100644 (file)
--- a/host/bigint_test.rb
+++ b/host/bigint_test.rb
@@ -407,6 +407,71 @@ def reduce_test(a,b)
   return false
 end
 
+################################################################################
+# mulmod_test                                                                  #
+################################################################################
+
+def mulmod_test(a,b,c)
+  begin
+    printf("[testing] mulmod(%#x, %#x, %#x)\n",a,b,c) if $debug
+    line = $sp.gets()
+    line = "" if line==nil
+    puts("DBG got: "+line) if $debug
+    if /^Error:.*/.match(line)
+      puts line
+      return false
+    end
+  end while ! /[\s]*enter a:[\s]*/.match(line)
+  $sp.print(a.to_s(16)+" ")
+  begin
+    line = $sp.gets()
+    line = "" if line==nil
+    puts("DBG got: "+line) if $debug
+    if /^Error:.*/.match(line)
+      puts line
+      return false
+    end
+  end while ! /[\s]*enter b:[\s]*/.match(line)
+  $sp.print(b.to_s(16)+" ")
+  begin
+    line = $sp.gets()
+    line = "" if line==nil
+    puts("DBG got: "+line) if $debug
+    if /^Error:.*/.match(line)
+      puts line
+      return false
+    end
+  end while ! /[\s]*enter c:[\s]*/.match(line)
+  $sp.print(c.to_s(16)+" ")
+  line=''
+  begin
+    line_tmp = $sp.gets()
+    line_tmp = '' if line_tmp==nil
+    line += line_tmp
+    puts("DBG got: "+line) if $debug
+    if /^Error:.*/.match(line)
+      puts line
+      return false
+    end
+    m = /[\s]*\([\s]*([+-]?[0-9a-fA-F]*)[\s]*\*[\s]*([+-]?[0-9a-fA-F]*)[\s]*\)[\s]+%[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
+    puts("DBG: line did not match pattern (" + line + ")") if !m && $debug
+  end while ! m 
+  a_ = m[1].to_i(16)
+  b_ = m[2].to_i(16)
+  c_ = m[3].to_i(16)
+  d_ = m[4].to_i(16)
+  line.chomp!
+  if(a_== a && b_ == b && c_ == c && d_ == (a * b % c) )
+    $logfile.printf("[pass]: %s\n", line)
+    return true
+  else
+    $logfile.printf("[fail (%s%s%s%s)]: %s", (a == a_) ? '' : 'a', (b == b_) ? '' : 'b', (c_ == c) ? '' : 'c', (d_== (a * b % c)) ? '' : 'd',line)
+    $logfile.printf(" ; should (%s * %s) %% %s = %s\n", a.to_s(16), b.to_s(16), c.to_s(16), (a * b % c).to_s(16))
+    return false
+  end
+  return false
+end
+
 ################################################################################
 # expmod_test                                                                  #
 ################################################################################
@@ -446,14 +511,14 @@ def expmod_test(a,b,c)
   line=''
   begin
     line_tmp = $sp.gets()
-    line_tmp = '' if line_tmp==nil
+    line_tmp = '' if line_tmp == nil
     line += line_tmp
     puts("DBG got: "+line) if $debug
-    if /^Error:.*/.match(line)
+    if /^Error:/.match(line)
       puts line
       return false
     end
-  end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)\*\*([+-]?[0-9a-fA-F]*)[\s]+%[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
+  end while ! m=/[\s]*([+-]?[0-9a-fA-F]+)\*\*([+-]?[0-9a-fA-F]+)[\s]+%[\s]+([+-]?[0-9a-fA-F]+)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
   a_ = m[1].to_i(16)
   b_ = m[2].to_i(16)
   c_ = m[3].to_i(16)
@@ -675,6 +740,24 @@ def run_test_mul(skip=0)
   end while length_a_B<4096/8
 end
 
+################################################################################
+# run_test_mul_word                                                                 #
+################################################################################
+
+def run_test_mul_word(skip=0)
+  length_a_B = skip+1
+  length_b_B = skip+1
+  begin
+    $size = length_a_B
+    (0..255).each do |i|
+      a = rand(256 ** length_a_B) 
+      v = mul_test(a, i)
+      screen_progress(v)   
+    end
+    length_a_B += 1
+  end while length_a_B < 4096 / 8
+end
+
 ################################################################################
 # run_test_square                                                              #
 ################################################################################
@@ -724,6 +807,66 @@ end
 ################################################################################
 
 def run_test_expmod(skip=0)
+  length_a_B = skip + 1
+  length_b_B = skip + 1
+  length_c_B = skip + 1
+  begin
+    $size = length_a_B
+    (0..16).each do |i|
+      a = rand(256 ** length_a_B)
+      b = rand(256 ** length_b_B) + 1
+      c = rand(256 ** length_c_B) + 1
+      v = expmod_test(a, b, c)
+      screen_progress(v)
+      end
+    (0..16).each do |i|
+      b_size = rand(length_b_B+1)
+      a = rand(256 ** length_a_B)
+      b = rand(256 ** b_size) + 1 
+      c = rand(256 ** b_size) + 1
+      v = expmod_test(a, b, c)
+      screen_progress(v)      
+      end
+    length_a_B += 1
+    length_b_B += 1
+  end while length_a_B<4096/8
+end
+
+################################################################################
+# run_test_expmodmont                                                          #
+################################################################################
+
+def run_test_expmodmont(skip=0)
+  length_a_B = skip + 1
+  length_b_B = skip + 1
+  length_c_B = skip + 1
+  begin
+    $size = length_a_B
+    (0..16).each do |i|
+      a = rand(256 ** length_a_B)
+      b = rand(256 ** length_b_B) + 1
+      c = rand(256 ** length_c_B) / 2 * 2 +1
+      v = expmod_test(a, b, c)
+      screen_progress(v)
+      end
+    (0..16).each do |i|
+      b_size = rand(length_b_B+1)
+      a = rand(256 ** length_a_B)
+      b = rand(256 ** b_size) + 1 
+      c = rand(256 ** b_size) / 2 * 2 +1
+      v = expmod_test(a, b, c)
+      screen_progress(v)      
+      end
+    length_a_B += 1
+    length_b_B += 1
+  end while length_a_B<4096/8
+end
+
+################################################################################
+# run_test_mulmod                                                              #
+################################################################################
+
+def run_test_mulmod(skip=0)
   length_a_B = skip+1
   length_b_B = skip+1
   length_c_B = skip+1
@@ -731,21 +874,26 @@ def run_test_expmod(skip=0)
     $size = length_a_B
     (0..16).each do |i|
       a = rand(256**length_a_B)
-      b = rand(256**length_b_B)+1
-      c = rand(256**length_c_B)+1
-      v = expmod_test(a, b, c)
+      b = rand(256**length_b_B)
+      c = (rand(256**length_c_B) / 2 * 2) + 1
+      a %= c
+      b %= c
+      v = mulmod_test(a, b, c)
       screen_progress(v)
       end
     (0..16).each do |i|
       b_size = rand(length_b_B+1)
       a = rand(256**length_a_B)
-      b = rand(256**b_size)+1 
-      c = rand(256**b_size)+1
-      v = expmod_test(a, b, c)
+      b = rand(256**b_size)
+      c = (rand(256**length_c_B) / 2 * 2) + 1
+      a %= c
+      b %= c
+      v = mulmod_test(a, b, c)
       screen_progress(v)      
       end
     length_a_B += 1
     length_b_B += 1
+    length_c_B += 1
   end while length_a_B<4096/8
 end
 
@@ -859,18 +1007,24 @@ $logfile.printf("seed = 0x%X\n", 0xdeadbeef)
 tests = Hash.new
 tests['a'] = proc {|x| run_test_add(x) }
 tests['m'] = proc {|x| run_test_mul(x) }
+tests['M'] = proc {|x| run_test_mulmod(x) }
+tests['n'] = proc {|x| run_test_mul_word(x) }
 tests['x'] = proc {|x| run_test_add_scale(x) }
 tests['s'] = proc {|x| run_test_square(x) }
 tests['r'] = proc {|x| run_test_reduce(x) }
 tests['e'] = proc {|x| run_test_expmod(x) }
+tests['E'] = proc {|x| run_test_expmodmont(x) }
 tests['g'] = proc {|x| run_test_gcdext(x) }
 init_str = Hash.new
 init_str['a'] = 'add-test'
 init_str['x'] = 'add-scale-test'
 init_str['m'] = 'mul-test'
+init_str['M'] = 'mul-mont-test'
+init_str['n'] = 'mul-word-test'
 init_str['s'] = 'square-test'
 init_str['r'] = 'reduce-test'
 init_str['e'] = 'expmod-test'
+init_str['E'] = 'expmod-mont-test'
 init_str['g'] = 'gcdext-test'
 
 srand(0xdeadbeef)
@@ -886,7 +1040,7 @@ if opts['a']
     end  
   end
 else
-  'amsre'.each_char do |x|
+  'amsrMeE'.each_char do |x|
     if tests[x]
       puts init_str[x]
       init_system(init_str[x])
@@ -896,6 +1050,6 @@ else
     end  
   end
 end
-
+1
 
 $logile.close()