bigint2_test.rb

   1 #!/usr/bin/ruby
   2 # bigint_test.rb
   3 =begin
   4     This file is part of the AVR-Crypto-Lib.
   5     Copyright (C) 2006-2015 Daniel Otte (bg@nerilex.org)
   6
   7     This program is free software: you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation, either version 3 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 =end
  20
  21 $debug = true
  22 $debug = false
  23 require 'rubygems'
  24 require 'serialport'
  25 require 'getopt/std'
  26 require 'fileutils'
  27 require 'date'
  28 $buffer_size = 0
  29 $conffile_check = Hash.new
  30 $conffile_check.default = 0
  31
  32 def max(a, b)
  33   return a > b ? a : b
  34 end
  35
  36 def min(a, b)
  37   return a < b ? a : b
  38 end
  39
  40 ################################################################################
  41 # readconfigfile                                                               #
  42 ################################################################################
  43
  44 def readconfigfile(fname, conf)
  45   return conf if $conffile_check[fname]==1
  46   $conffile_check[fname]=1
  47   section = "default"
  48   if ! File.exists?(fname)
  49     return conf
  50   end
  51   file = File.open(fname, "r")
  52   until file.eof
  53     line = file.gets()
  54         next if /[\s]*#/.match(line)
  55         if m=/\[[\s]*([^\s]*)[\s]*\]/.match(line)
  56           section=m[1]
  57           conf[m[1]] = Hash.new
  58           next
  59         end
  60         next if ! /=/.match(line)
  61         m=/[\s]*([^\s]*)[\s]*=[\s]*([^\s]*)/.match(line)
  62         if m[1]=="include"
  63           Dir.glob(m[2]){ |fn| conf = readconfigfile(fn, conf) }
  64         else
  65           conf[section][m[1]] = m[2]
  66         end
  67   end
  68   file.close()
  69   return conf
  70 end
  71
  72 ################################################################################
  73 # expmod                                                                       #
  74 ################################################################################
  75
  76 def expmod(base, power, mod)
  77   result = 1
  78   while power > 0
  79     result = (result * base) % mod if power & 1 == 1
  80     base = (base * base) % mod
  81     power >>= 1;
  82   end
  83   return result
  84 end
  85
  86 ################################################################################
  87 # gcdext                                                                 #
  88 ################################################################################
  89
  90 def gcdext(x,y)
  91   return  [0, 0, 0] if(x == 0 || y == 0)
  92   g=1
  93   while(x&1==0 && y&1==0) do
  94     x>>=1
  95     y>>=1
  96     g<<=1
  97   end
  98   u=x; v=y; a=1; b=0; c=0; d=1
  99   begin
 100     while(u&1==0) do
 101       if(a%2==1 || b%2==1)
 102         a += y
 103         b -= x
 104       end
 105       u>>=1; a>>=1; b>>=1
 106     end
 107     while(v&1==0) do
 108       if(c%2==1 || d%2==1)
 109         c += y
 110         d -= x
 111       end
 112       v>>=1; c>>=1; d>>=1;
 113     end
 114     if(u>=v)
 115       u -= v; a-=c; b-=d
 116     else
 117       v -= u; c-=a; d-=b
 118     end
 119   end while(u!=0)
 120   return[g*v, c, d]
 121 end
 122
 123 ################################################################################
 124 # reset_system                                                                 #
 125 ################################################################################
 126
 127 def reset_system
 128   $sp.print("exit\r")
 129   sleep 0.1
 130   $sp.print("exit\r")
 131   sleep 0.1
 132 end
 133
 134 ################################################################################
 135 # init_system                                                                  #
 136 ################################################################################
 137
 138 def init_system(test_prog)
 139   begin
 140     line = $sp.gets()
 141   end while line!=nil
 142   $sp.print("echo off \r")
 143   print("DBG i: " + "echo off \r"+"\n") if $debug
 144   sleep 0.1
 145   $sp.print("#{test_prog}\r")
 146   print("DBG i: " + "#{test_prog} \r"+"\n") if $debug
 147   sleep 1
 148 end
 149
 150 ################################################################################
 151 # wait_for_prompt                                                                  #
 152 ################################################################################
 153
 154 def wait_for_prompt(prompt)
 155   prompt = /[\s]*#{prompt}[\s]*/ if(prompt.class == String)
 156   start_time = Time.now.to_i
 157   acc = ''
 158   begin
 159     line = $sp.gets()
 160     puts("DBG got (#{__LINE__}): "+line) if $debug && line
 161     line = "" if line==nil
 162     if /^(Error:|Crypto-VS).*/.match(line)
 163       puts line
 164       return false
 165     end
 166     if (Time.now.to_i- start_time) > $max_timeout
 167       return false
 168     end
 169   acc += line
 170   end while ! m=prompt.match(acc)
 171   return m
 172 end
 173
 174 ################################################################################
 175 # screen_progress                                                              #
 176 ################################################################################
 177 def screen_progress(v)
 178   if $linepos == 0
 179     printf("\n%5d [%04d]: ", $testno, $size)
 180   end
 181   putc((v)?('*'):('!'))
 182   $testno += 1
 183   $linepos = ($linepos+1) % $linewidth
 184 end
 185
 186 ################################################################################
 187 # add_test                                                                     #
 188 ################################################################################
 189
 190 def add_test(a,b)
 191   begin
 192     line = $sp.gets()
 193     line = "" if line==nil
 194     puts("DBG got: "+line) if $debug
 195     if /^Error:.*/.match(line)
 196       puts line
 197       return false
 198     end
 199   end while ! /[\s]*enter a:[\s]*/.match(line)
 200   $sp.print(a.to_s(16)+" ")
 201   begin
 202     line = $sp.gets()
 203     line = "" if line==nil
 204     puts("DBG got: "+line) if $debug
 205     if /^Error:.*/.match(line)
 206       puts line
 207       return false
 208     end
 209   end while ! /[\s]*enter b:[\s]*/.match(line)
 210   $sp.print(b.to_s(16)+" ")
 211   begin
 212     line = $sp.gets()
 213     line = "" if line==nil
 214     puts("DBG got: "+line) if $debug
 215     if /^Error:.*/.match(line)
 216       puts line
 217       return false
 218     end
 219   end while ! m=/[\s]*([-]?[0-9a-fA-F]*)[\s]+\+[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
 220   a_ = m[1].to_i(16)
 221   b_ = m[2].to_i(16)
 222   c_ = m[3].to_i(16)
 223   line.chomp!
 224   if(a_== a && b_ == b && c_ == (a+b))
 225     $logfile.printf("[pass (%d)]: %s\n", $testno, line)
 226     return true
 227   else
 228     $logfile.printf("[fail (%s%s%s) (%d)]: %s",
 229       (a == a_) ? "" : "a",
 230       (b == b_) ? "" : "b",
 231       (c_ == a + b) ?  "" : "c", $testno, line)
 232     $logfile.printf(" ; should %s + %s = %s\n", a.to_s(16), b.to_s(16), (a+b).to_s(16))
 233     return false
 234   end
 235   return false
 236 end
 237
 238 ################################################################################
 239 # sub_test                                                                     #
 240 ################################################################################
 241
 242 def sub_test(a, b)
 243   begin
 244     line = $sp.gets()
 245     line = "" if line==nil
 246     puts("DBG got: "+line) if $debug
 247     if /^Error:.*/.match(line)
 248       puts line
 249       return false
 250     end
 251   end while ! /[\s]*enter a:[\s]*/.match(line)
 252   $sp.print(a.to_s(16)+" ")
 253   begin
 254     line = $sp.gets()
 255     line = "" if line==nil
 256     puts("DBG got: "+line) if $debug
 257     if /^Error:.*/.match(line)
 258       puts line
 259       return false
 260     end
 261   end while ! /[\s]*enter b:[\s]*/.match(line)
 262   $sp.print(b.to_s(16)+" ")
 263   begin
 264     line = $sp.gets()
 265     line = "" if line==nil
 266     puts("DBG got: "+line) if $debug
 267     if /^Error:.*/.match(line)
 268       puts line
 269       return false
 270     end
 271   end while ! m=/[\s]*([-]?[0-9a-fA-F]*)[\s]+\-[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
 272   a_ = m[1].to_i(16)
 273   b_ = m[2].to_i(16)
 274   c_ = m[3].to_i(16)
 275   line.chomp!
 276   if(a_== a && b_ == b && c_ == (a - b))
 277     $logfile.printf("[pass (%d)]: %s\n", $testno, line)
 278     return true
 279   else
 280     $logfile.printf("[fail (%s%s%s) (%d)]: %s",
 281       (a == a_) ? "" : "a",
 282       (b == b_) ? "" : "b",
 283       (c_ == a - b) ? "" : "c", $testno, line)
 284     $logfile.printf(" ; should %s - %s = %s\n", a.to_s(16), b.to_s(16), (a - b).to_s(16))
 285     return false
 286   end
 287   return false
 288 end
 289
 290 ################################################################################
 291 # mul_test                                                                     #
 292 ################################################################################
 293
 294 def mul_test(a,b)
 295   begin
 296     line = $sp.gets()
 297     line = "" if line==nil
 298     puts("DBG got: "+line) if $debug
 299     if /^Error:.*/.match(line)
 300       puts line
 301       return false
 302     end
 303   end while ! /[\s]*enter a:[\s]*/.match(line)
 304   $sp.print(a.to_s(16)+" ")
 305   begin
 306     line = $sp.gets()
 307     line = "" if line==nil
 308     puts("DBG got: "+line) if $debug
 309     if /^Error:.*/.match(line)
 310       puts line
 311       return false
 312     end
 313   end while ! /[\s]*enter b:[\s]*/.match(line)
 314   $sp.print(b.to_s(16)+" ")
 315   begin
 316     line = $sp.gets()
 317     line = "" if line==nil
 318     puts("DBG got: "+line) if $debug
 319     if /^Error:.*/.match(line)
 320       puts line
 321       return false
 322     end
 323   end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]+\*[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
 324   a_ = m[1].to_i(16)
 325   b_ = m[2].to_i(16)
 326   c_ = m[3].to_i(16)
 327   line.chomp!
 328   if(a_== a && b_ == b && c_ == (a*b))
 329     $logfile.printf("[pass]: %s\n", line)
 330     return true
 331   else
 332     $logfile.printf("[fail (%s%s%s)]: %s", (a==a_)?"":"a", (b==b_)?"":"b", (c_==a*b)?"":"c",line)
 333     $logfile.printf(" ; should %s * %s = %s\n", a.to_s(16), b.to_s(16), (a*b).to_s(16))
 334     return false
 335   end
 336   return false
 337 end
 338
 339 ################################################################################
 340 # add_scale_test                                                               #
 341 ################################################################################
 342 def add_scale_test_dummy(a, b, scale)
 343   should = a + (b<<(8*scale))
 344   printf("[dummy] %s + %s <<8*%04x = %s\n",a.to_s(16), b.to_s(16), scale, should.to_s(16))
 345 end
 346
 347 def add_scale_test(a, b, scale)
 348   m = wait_for_prompt("enter a:")
 349   return false if !m
 350   puts("DBG put (#{__LINE__}): "+a.to_s(16)+" ") if $debug
 351   $sp.print(a.to_s(16)+" ")
 352   m = wait_for_prompt("enter b:")
 353   return false if !m
 354   puts("DBG put (#{__LINE__}): "+b.to_s(16)+" ") if $debug
 355   $sp.print(b.to_s(16)+" ")
 356   m = wait_for_prompt("enter scale:")
 357   return false if !m
 358   puts("DBG put (#{__LINE__}): "+scale.to_s(10)+" ") if $debug
 359   $sp.print(scale.to_s(10)+"\r")
 360   should = a + (b<<(8*scale))
 361   m = wait_for_prompt(/[\s]*([-]?[0-9a-fA-F]+)[\s]+\+[\s]+([+-]?[0-9a-fA-F]+)[\s]*<<8\*[\s]*([+-]?[0-9a-fA-F]+)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/)
 362   if !m
 363     $logfile.printf("[fail (CRASH)]:")
 364     $logfile.printf(" ; should %s + %s << 8*%s = %s\n", a.to_s(16), b.to_s(16), scale.to_s(16), should.to_s(16))
 365     return false
 366   end
 367   line = m[0]
 368   a_ = m[1].to_i(16)
 369   b_ = m[2].to_i(16)
 370   s_ = m[3].to_i(16)
 371   c_ = m[4].to_i(16)
 372   line.chomp!
 373   if(a_== a && b_ == b && s_ == scale && c_ == should )
 374     $logfile.printf("[pass]: %s\n", line)
 375     return true
 376   else
 377     $logfile.printf("[fail (%s%s%s%s)]: %s", (a==a_)?"":"a", (b==b_)?"":"b", (scale==s_)?"":"s",(c_==should)?"":"c",line)
 378     $logfile.printf(" ; should %s + %s << 8*%s = %s\n", a.to_s(16), b.to_s(16), scale.to_s(16), should.to_s(16))
 379     return false
 380   end
 381   return false
 382 end
 383
 384 ################################################################################
 385 # square_test                                                                  #
 386 ################################################################################
 387
 388 def square_test(a)
 389   begin
 390     line = $sp.gets()
 391     line = "" if line==nil
 392     puts("DBG got: "+line) if $debug
 393     if /^Error:.*/.match(line)
 394       puts line
 395       return false
 396     end
 397   end while ! /[\s]*enter a:[\s]*/.match(line)
 398   $sp.print(a.to_s(16)+" ")
 399   begin
 400     line = $sp.gets()
 401     line = "" if line==nil
 402     puts("DBG got: "+line) if $debug
 403     if /^Error:.*/.match(line)
 404       puts line
 405       return false
 406     end
 407   end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]*\*\*2[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
 408   a_ = m[1].to_i(16)
 409   c_ = m[2].to_i(16)
 410   line.chomp!
 411   if(a_== a && c_ == (a**2))
 412     $logfile.printf("[pass]: %s\n", line)
 413     return true
 414   else
 415     $logfile.printf("[fail (%s%s)]: %s", (a==a_)?"":"a", (c_==a**2)?"":"c",line)
 416     $logfile.printf(" ; should %s **2 = %s\n", a.to_s(16), (a**2).to_s(16))
 417     return false
 418   end
 419   return false
 420 end
 421
 422 ################################################################################
 423 # reduce_test                                                                  #
 424 ################################################################################
 425
 426 def reduce_test(a,b)
 427   begin
 428     line = $sp.gets()
 429     line = "" if line==nil
 430     puts("DBG got: "+line) if $debug
 431     if /^Error:.*/.match(line)
 432       puts line
 433       return false
 434     end
 435   end while ! /[\s]*enter a:[\s]*/.match(line)
 436   $sp.print(a.to_s(16)+" ")
 437   begin
 438     line = $sp.gets()
 439     line = "" if line==nil
 440     puts("DBG got: "+line) if $debug
 441     if /^Error:.*/.match(line)
 442       puts line
 443       return false
 444     end
 445   end while ! /[\s]*enter b:[\s]*/.match(line)
 446   $sp.print(b.to_s(16)+" ")
 447   line=''
 448   begin
 449     line_tmp = $sp.gets()
 450     line_tmp = '' if line_tmp==nil
 451     line += line_tmp
 452     puts("DBG got: "+line) if $debug
 453     if /^Error:.*/.match(line)
 454       puts line
 455       return false
 456     end
 457   end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]+%[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
 458   a_ = m[1].to_i(16)
 459   b_ = m[2].to_i(16)
 460   c_ = m[3].to_i(16)
 461   line.strip!
 462   if(a_== a && b_ == b && c_ == (a%b))
 463     $logfile.printf("[pass (%d)]: %s\n", $testno, line)
 464     return true
 465   else
 466     $logfile.printf("[fail (%s%s%s) (%d)]: %s",
 467       (a == a_) ? "" : "a",
 468       (b == b_) ? "" : "b",
 469       (c_ == a % b) ? "" : "c", $testno, line)
 470     $logfile.printf(" ; should %s %% %s = %s\n", a.to_s(16), b.to_s(16), (a % b).to_s(16))
 471     return false
 472   end
 473   return false
 474 end
 475
 476 ################################################################################
 477 # div_test                                                                  #
 478 ################################################################################
 479
 480 def div_test(a, b)
 481   begin
 482     line = $sp.gets()
 483     line = "" if line==nil
 484     puts("DBG got: "+line) if $debug
 485     if /^Error:.*/.match(line)
 486       puts line
 487       return false
 488     end
 489   end while ! /[\s]*enter a:[\s]*/.match(line)
 490   $sp.print(a.to_s(16) + " ")
 491   begin
 492     line = $sp.gets()
 493     line = "" if line == nil
 494     puts("DBG got: " + line) if $debug
 495     if /^Error:.*/.match(line)
 496       puts line
 497       return false
 498     end
 499   end while ! /[\s]*enter b:[\s]*/.match(line)
 500   $sp.print(b.to_s(16) + " ")
 501   line = ''
 502   begin
 503     line_tmp = $sp.gets()
 504     line_tmp = '' if line_tmp == nil
 505     line += line_tmp
 506     puts("DBG got: " + line) if $debug
 507     if /^Error:.*/.match(line)
 508       puts line
 509       return false
 510     end
 511   end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]+\/[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]+);[\s]*R[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
 512   a_ = m[1].to_i(16)
 513   b_ = m[2].to_i(16)
 514   c_ = m[3].to_i(16)
 515   d_ = m[4].to_i(16)
 516   line.strip!
 517   if (a_== a && b_ == b && c_ == (a / b) && d_ == (a % b))
 518     $logfile.printf("[pass (%d)]: %s\n", $testno, line)
 519     return true
 520   else
 521     $logfile.printf("[fail (%s%s%s%s) (%d)]: %s",
 522       (a == a_) ? "" : "a",
 523       (b == b_) ? "" : "b",
 524       (c_ == a / b) ? "" : "c",
 525       (d_ == a % b) ? "" : "d", $testno, line)
 526     $logfile.printf(" ; should %s %% %s = %s; R = %s\n", a.to_s(16), b.to_s(16), (a / b).to_s(16), (a % b).to_s(16))
 527     return false
 528   end
 529   return false
 530 end
 531
 532 ################################################################################
 533 # mulmod_test                                                                  #
 534 ################################################################################
 535
 536 def mulmod_test(a,b,c)
 537   begin
 538     printf("[testing] mulmod(%#x, %#x, %#x)\n",a,b,c) if $debug
 539     line = $sp.gets()
 540     line = "" if line==nil
 541     puts("DBG got: "+line) if $debug
 542     if /^Error:.*/.match(line)
 543       puts line
 544       return false
 545     end
 546   end while ! /[\s]*enter a:[\s]*/.match(line)
 547   $sp.print(a.to_s(16)+" ")
 548   begin
 549     line = $sp.gets()
 550     line = "" if line==nil
 551     puts("DBG got: "+line) if $debug
 552     if /^Error:.*/.match(line)
 553       puts line
 554       return false
 555     end
 556   end while ! /[\s]*enter b:[\s]*/.match(line)
 557   $sp.print(b.to_s(16)+" ")
 558   begin
 559     line = $sp.gets()
 560     line = "" if line==nil
 561     puts("DBG got: "+line) if $debug
 562     if /^Error:.*/.match(line)
 563       puts line
 564       return false
 565     end
 566   end while ! /[\s]*enter c:[\s]*/.match(line)
 567   $sp.print(c.to_s(16)+" ")
 568   line=''
 569   begin
 570     line_tmp = $sp.gets()
 571     line_tmp = '' if line_tmp==nil
 572     line += line_tmp
 573     puts("DBG got: "+line) if $debug
 574     if /^Error:.*/.match(line)
 575       puts line
 576       return false
 577     end
 578     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)
 579     puts("DBG: line did not match pattern (" + line + ")") if !m && $debug
 580   end while ! m
 581   a_ = m[1].to_i(16)
 582   b_ = m[2].to_i(16)
 583   c_ = m[3].to_i(16)
 584   d_ = m[4].to_i(16)
 585   line.chomp!
 586   if(a_== a && b_ == b && c_ == c && d_ == (a * b % c) )
 587     $logfile.printf("[pass]: %s\n", line)
 588     return true
 589   else
 590     $logfile.printf("[fail (%s%s%s%s)]: %s", (a == a_) ? '' : 'a', (b == b_) ? '' : 'b', (c_ == c) ? '' : 'c', (d_== (a * b % c)) ? '' : 'd',line)
 591     $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))
 592     return false
 593   end
 594   return false
 595 end
 596
 597 ################################################################################
 598 # expmod_test                                                                  #
 599 ################################################################################
 600
 601 def expmod_test(a,b,c)
 602   begin
 603     printf("[testing] expmod(%#x, %#x, %#x)\n",a,b,c) if $debug
 604     line = $sp.gets()
 605     line = "" if line==nil
 606     puts("DBG got: "+line) if $debug
 607     if /^Error:.*/.match(line)
 608       puts line
 609       return false
 610     end
 611   end while ! /[\s]*enter a:[\s]*/.match(line)
 612   $sp.print(a.to_s(16)+" ")
 613   begin
 614     line = $sp.gets()
 615     line = "" if line==nil
 616     puts("DBG got: "+line) if $debug
 617     if /^Error:.*/.match(line)
 618       puts line
 619       return false
 620     end
 621   end while ! /[\s]*enter b:[\s]*/.match(line)
 622   $sp.print(b.to_s(16)+" ")
 623   begin
 624     line = $sp.gets()
 625     line = "" if line==nil
 626     puts("DBG got: "+line) if $debug
 627     if /^Error:.*/.match(line)
 628       puts line
 629       return false
 630     end
 631   end while ! /[\s]*enter c:[\s]*/.match(line)
 632   $sp.print(c.to_s(16)+" ")
 633   line=''
 634   begin
 635     line_tmp = $sp.gets()
 636     line_tmp = '' if line_tmp == nil
 637     line += line_tmp
 638     puts("DBG got: "+line) if $debug
 639     if /^Error:/.match(line)
 640       puts line
 641       return false
 642     end
 643   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)
 644   a_ = m[1].to_i(16)
 645   b_ = m[2].to_i(16)
 646   c_ = m[3].to_i(16)
 647   d_ = m[4].to_i(16)
 648   line.chomp!
 649   if(a_== a && b_ == b && c_ == c && d_ ==expmod(a,b,c) )
 650     $logfile.printf("[pass]: %s\n", line)
 651     return true
 652   else
 653     $logfile.printf("[fail (%s%s%s%s)]: %s", (a==a_)?'':'a', (b==b_)?'':'b', (c_==c)?'':'c', (d_==expmod(a,b,c))?'':'d',line)
 654     $logfile.printf(" ; should %s**%s %% %s = %s\n", a.to_s(16), b.to_s(16), c.to_s(16), expmod(a,b,c).to_s(16))
 655     return false
 656   end
 657   return false
 658 end
 659
 660 ################################################################################
 661 # gcdext_test                                                                  #
 662 ################################################################################
 663
 664 def gcdext_test(a,b)
 665   $logfile.printf("[testing] gcdext(%s, %s)\n", a.to_s(16), b.to_s(16))
 666   begin
 667     line = $sp.gets()
 668     line = "" if line==nil
 669     puts("DBG got: "+line) if $debug
 670     if /^Error:.*/.match(line)
 671       puts line
 672       return false
 673     end
 674   end while ! /[\s]*enter a:[\s]*/.match(line)
 675   $sp.print(a.to_s(16)+" ")
 676   begin
 677     line = $sp.gets()
 678     line = "" if line==nil
 679     puts("DBG got: "+line) if $debug
 680     if /^Error:.*/.match(line)
 681       puts line
 682       return false
 683     end
 684   end while ! /[\s]*enter b:[\s]*/.match(line)
 685   $sp.print(b.to_s(16)+" ")
 686   line=''
 687   begin
 688     line_tmp = $sp.gets()
 689     line_tmp = '' if line_tmp==nil
 690     line = ''  if line.end_with?('\n')
 691     line += line_tmp
 692     puts("DBG got: "+line) if $debug
 693     if /^Error:.*/.match(line)
 694       puts line
 695       return false
 696     end
 697   end while ! m=/gcdext\([\s]*([+-]?[0-9a-fA-F]*)[\s]*,[\s]*([+-]?[0-9a-fA-F]*)[\s]*\)[\s]*=> a = ([+-]?[0-9a-fA-F]+); b = ([+-]?[0-9a-fA-F]+); gcd = ([+-]?[0-9a-fA-F]+)/.match(line)
 698   a_ = m[1].to_i(16)
 699   b_ = m[2].to_i(16)
 700   c_ = m[3].to_i(16)
 701   d_ = m[4].to_i(16)
 702   e_ = m[5].to_i(16)
 703   line.chomp!
 704   line.gsub!("\r",'')
 705   line.gsub!("\n",'')
 706   ref = gcdext(a,b)
 707   if(a_== a && b_ == b && c_ == ref[1] && d_ == ref[2] && e_== ref[0])
 708     $logfile.printf("[pass (%d)]: %s\n", $testno, line)
 709     return true
 710   else
 711     $logfile.printf("[fail (%s%s%s%s%s) (%d)]: %s",
 712       (a == a_) ? '' : 'a',
 713       (b == b_) ? '' : 'b',
 714       (c_ == ref[1]) ? '' : 'c',
 715       (d_ == ref[2]) ? '' : 'd',
 716       (e_ == ref[0]) ? '' : 'e', $testno, line)
 717     $logfile.printf(" ; should gcdext( %s, %s) => a = %s; b = %s; gcd = %s\n",
 718        a.to_s(16), b.to_s(16), ref[1].to_s(16), ref[2].to_s(16), ref[0].to_s(16))
 719     return false
 720   end
 721   return false
 722 end
 723
 724 ################################################################################
 725 # run_test_add                                                                 #
 726 ################################################################################
 727
 728 def run_test_add(skip=0)
 729   length_a_B = skip+1
 730   length_b_B = skip+1
 731   begin
 732     $size = length_a_B
 733     (0..16).each do |i|
 734       a = rand(256**length_a_B)
 735       b = rand(256**length_a_B)
 736       v = add_test(a, b)
 737       screen_progress(v)
 738       v = add_test(b, a)
 739       screen_progress(v)
 740     end
 741     (0..16).each do |i|
 742       b_size = rand(length_b_B+1)
 743       a = rand(256**length_a_B)
 744       b = rand(256**b_size)
 745       v = add_test(a, b)
 746       screen_progress(v)
 747       v = add_test(b, a)
 748       screen_progress(v)
 749     end
 750     length_a_B += 1
 751     length_b_B += 1
 752   end while length_a_B<4096/8
 753 end
 754
 755 ################################################################################
 756 # run_test_sub                                                                 #
 757 ################################################################################
 758
 759 def run_test_sub(skip = 0)
 760   length_a_B = skip + 1
 761   length_b_B = skip + 1
 762   begin
 763     $size = length_a_B
 764     (0..16).each do |i|
 765       a = rand(256 ** length_a_B)
 766       b = rand(a + 1)
 767       v = sub_test(a, b)
 768       screen_progress(v)
 769     end
 770     (0..16).each do |i|
 771       b_size = rand(length_b_B + 1)
 772       a = rand(256 ** length_a_B)
 773       b = rand(min(256 ** b_size, a + 1))
 774       v = sub_test(a, b)
 775       screen_progress(v)
 776     end
 777     length_a_B += 1
 778     length_b_B += 1
 779   end while length_a_B < 4096 / 8
 780 end
 781
 782
 783 ################################################################################
 784 # run_test_add_scale                                                           #
 785 ################################################################################
 786
 787 def run_test_add_scale(skip=0)
 788   length_a_B = skip+1
 789   length_b_B = skip+1
 790   begin
 791     $size = length_a_B
 792     (0..4).each do |i|
 793       scales = [0, 300]
 794       16.times { scales << rand(301) }
 795       scales.sort!
 796       scales.each do |scale|
 797         a = rand(256**length_a_B)
 798         b = rand(256**length_a_B)
 799         v = add_scale_test(a, b, scale)
 800         screen_progress(v)
 801         v = add_scale_test(b, a, scale)
 802         screen_progress(v)
 803       end
 804     end
 805     (0..4).each do |i|
 806       scales = [0, 300]
 807       16.times { scales << rand(301) }
 808       scales.sort!
 809       scales.each do |scale|
 810         b_size = rand(length_b_B+1)+1
 811         a = rand(256**length_a_B)
 812         b = rand(256**b_size)
 813         v = add_scale_test(a, b, scale)
 814         screen_progress(v)
 815         v = add_scale_test(b, a, scale)
 816         screen_progress(v)
 817       end
 818     end
 819     length_a_B += 10
 820     length_b_B += 10
 821   end while length_a_B<4096/8
 822 end
 823
 824 def run_test_add_scale_dummy(skip=0)
 825   length_a_B = skip+1
 826   length_b_B = skip+1
 827   begin
 828     $size = length_a_B
 829     (0..4).each do |i|
 830       scales = [0, 300]
 831       16.times { scales << rand(301) }
 832       scales.sort!
 833       scales.each do |scale|
 834         a = rand(256**length_a_B)
 835         b = rand(256**length_a_B)
 836         v = add_scale_test_dummy(a, b, scale)
 837         v = add_scale_test_dummy(b, a, scale)
 838       end
 839     end
 840     (0..4).each do |i|
 841       scales = [0, 300]
 842       16.times { scales << rand(301) }
 843       scales.sort!
 844       scales.each do |scale|
 845         b_size = rand(length_b_B+1)
 846         a = rand(256**length_a_B)
 847         b = rand(256**b_size)
 848         v = add_scale_test_dummy(a, b, scale)
 849         v = add_scale_test_dummy(b, a, scale)
 850       end
 851     end
 852     length_a_B += 10
 853     length_b_B += 10
 854   end while length_a_B<4096/8
 855 end
 856
 857 ################################################################################
 858 # run_test_mul                                                                 #
 859 ################################################################################
 860
 861 def run_test_mul(skip=0)
 862   length_a_B = skip+1
 863   length_b_B = skip+1
 864   begin
 865     $size = length_a_B
 866     (0..16).each do |i|
 867       s_a = rand(2)*2-1
 868       s_b = rand(2)*2-1
 869       a = rand(256**length_a_B) * s_a
 870       b = rand(256**length_a_B) * s_b
 871       v = mul_test(a, b)
 872       screen_progress(v)
 873       v = mul_test(b, a)
 874       screen_progress(v)
 875     end
 876     (0..16).each do |i|
 877       s_a = rand(2)-1
 878       s_b = rand(2)-1
 879       b_size = rand(length_b_B+1)
 880       a = rand(256**length_a_B) * s_a
 881       b = rand(256**b_size) * s_b
 882       v = mul_test(a, b)
 883       screen_progress(v)
 884       v = mul_test(b, a)
 885       screen_progress(v)
 886     end
 887     length_a_B += 1
 888     length_b_B += 1
 889   end while length_a_B<4096/8
 890 end
 891
 892 ################################################################################
 893 # run_test_mul_word                                                                 #
 894 ################################################################################
 895
 896 def run_test_mul_word(skip=0)
 897   length_a_B = skip+1
 898   length_b_B = skip+1
 899   begin
 900     $size = length_a_B
 901     (0..255).each do |i|
 902       a = rand(256 ** length_a_B)
 903       v = mul_test(a, i)
 904       screen_progress(v)
 905     end
 906     length_a_B += 1
 907   end while length_a_B < 4096 / 8
 908 end
 909
 910 ################################################################################
 911 # run_test_square                                                              #
 912 ################################################################################
 913
 914 def run_test_square(skip=0)
 915   length_a_B = skip+1
 916   begin
 917     $size = length_a_B
 918     (0..16).each do |i|
 919       a = rand(256**length_a_B)
 920       v = square_test(a)
 921       screen_progress(v)
 922     end
 923     length_a_B += 1
 924   end while length_a_B<4096/8
 925 end
 926
 927 ################################################################################
 928 # run_test_reduce                                                              #
 929 ################################################################################
 930
 931 def run_test_reduce(skip=0)
 932   length_a_B = skip+1
 933   length_b_B = skip+1
 934   begin
 935     $size = length_a_B
 936     (0..16).each do |i|
 937       a = rand(256**length_a_B)
 938       b = rand(256**length_a_B)+1
 939       v = reduce_test(a, b)
 940       screen_progress(v)
 941       end
 942     (0..16).each do |i|
 943       b_size = rand(length_b_B+1)
 944       a = rand(256**length_a_B)
 945       b = rand(256**b_size)+1
 946       v = reduce_test(a, b)
 947       screen_progress(v)
 948       end
 949     length_a_B += 1
 950     length_b_B += 1
 951   end while length_a_B < 4096 / 8
 952 end
 953
 954 ################################################################################
 955 # run_test_div                                                              #
 956 ################################################################################
 957
 958 def run_test_div(skip=0)
 959   length_a_B = skip + 1
 960   length_b_B = skip + 1
 961   begin
 962     $size = length_a_B
 963     (0..16).each do |i|
 964       a = rand(256 ** length_a_B)
 965       b = rand(256 ** length_a_B) + 1
 966       v = div_test(a, b)
 967       screen_progress(v)
 968       end
 969     (0..16).each do |i|
 970       b_size = rand(length_b_B + 1)
 971       a = rand(256 ** length_a_B)
 972       b = rand(256 ** b_size) + 1
 973       v = div_test(a, b)
 974       screen_progress(v)
 975       end
 976     length_a_B += 1
 977     length_b_B += 1
 978   end while length_a_B < 4096 / 8
 979 end
 980
 981 ################################################################################
 982 # run_test_expmod                                                              #
 983 ################################################################################
 984
 985 def run_test_expmod(skip=0)
 986   length_a_B = skip + 1
 987   length_b_B = skip + 1
 988   length_c_B = skip + 1
 989   begin
 990     $size = length_a_B
 991     (0..16).each do |i|
 992       a = rand(256 ** length_a_B)
 993       b = rand(256 ** length_b_B) + 1
 994       c = rand(256 ** length_c_B) + 1
 995       v = expmod_test(a, b, c)
 996       screen_progress(v)
 997       end
 998     (0..16).each do |i|
 999       b_size = rand(length_b_B+1)
1000       a = rand(256 ** length_a_B)
1001       b = rand(256 ** b_size) + 1
1002       c = rand(256 ** b_size) + 1
1003       v = expmod_test(a, b, c)
1004       screen_progress(v)
1005       end
1006     length_a_B += 1
1007     length_b_B += 1
1008   end while length_a_B<4096/8
1009 end
1010
1011 ################################################################################
1012 # run_test_expmodmont                                                          #
1013 ################################################################################
1014
1015 def run_test_expmodmont(skip=0)
1016   length_a_B = skip + 1
1017   length_b_B = skip + 1
1018   length_c_B = skip + 1
1019   begin
1020     $size = length_a_B
1021     (0..16).each do |i|
1022       a = rand(256 ** length_a_B)
1023       b = rand(256 ** length_b_B) + 1
1024       c = rand(256 ** length_c_B) / 2 * 2 +1
1025       v = expmod_test(a, b, c)
1026       screen_progress(v)
1027       end
1028     (0..16).each do |i|
1029       b_size = rand(length_b_B + 10)
1030       a = rand(256 ** length_a_B)
1031       b = rand(256 ** b_size) + 1
1032       c = rand(256 ** b_size) / 2 * 2 +1
1033       v = expmod_test(a, b, c)
1034       screen_progress(v)
1035       end
1036     length_a_B += 1
1037     length_b_B += 1
1038   end while length_a_B<4096/8
1039 end
1040
1041 ################################################################################
1042 # run_test_mulmod                                                              #
1043 ################################################################################
1044
1045 def run_test_mulmod(skip=0)
1046   length_a_B = skip+1
1047   length_b_B = skip+1
1048   length_c_B = skip+1
1049   begin
1050     $size = length_a_B
1051     (0..16).each do |i|
1052       a = rand(256**length_a_B)
1053       b = rand(256**length_b_B)
1054       c = (rand(256**length_c_B) / 2 * 2) + 1
1055       a %= c
1056       b %= c
1057       v = mulmod_test(a, b, c)
1058       screen_progress(v)
1059       end
1060     (0..16).each do |i|
1061       b_size = rand(length_b_B+1)
1062       a = rand(256**length_a_B)
1063       b = rand(256**b_size)
1064       c = (rand(256**length_c_B) / 2 * 2) + 1
1065       a %= c
1066       b %= c
1067       v = mulmod_test(a, b, c)
1068       screen_progress(v)
1069       end
1070     length_a_B += 1
1071     length_b_B += 1
1072     length_c_B += 1
1073   end while length_a_B<4096/8
1074 end
1075
1076 ################################################################################
1077 # run_test_gcdext                                                              #
1078 ################################################################################
1079
1080 def run_test_gcdext(skip=0)
1081   length_a_B = skip+1
1082   length_b_B = skip+1
1083   begin
1084     $size = length_a_B
1085     (0..16).each do |i|
1086       a = rand(256**length_a_B)
1087       b = rand(256**length_a_B)+1
1088       v = gcdext_test(a, b)
1089       $logfile.flush()
1090       screen_progress(v)
1091       end
1092     (0..16).each do |i|
1093       b_size = rand(length_b_B+1)
1094       a = rand(256**length_a_B)
1095       b = rand(256**b_size)+1
1096       v = gcdext_test(a, b)
1097       $logfile.flush()
1098       screen_progress(v)
1099       end
1100     length_a_B += 1
1101     length_b_B += 1
1102   end while length_a_B<4096/8
1103 end
1104
1105 def init_serialport(conf)
1106   puts("serial port interface version: " + SerialPort::VERSION);
1107   $linewidth = 64
1108   $linepos = 0
1109   $testno = 0
1110   params = { "baud"       => conf["PORT"]["baud"].to_i,
1111               "data_bits" => conf["PORT"]["databits"].to_i,
1112               "stop_bits" => conf["PORT"]["stopbits"].to_i,
1113               "parity"    => SerialPort::NONE }
1114   params["paraty"] = SerialPort::ODD   if conf["PORT"]["paraty"].downcase == "odd"
1115   params["paraty"] = SerialPort::EVEN  if conf["PORT"]["paraty"].downcase == "even"
1116   params["paraty"] = SerialPort::MARK  if conf["PORT"]["paraty"].downcase == "mark"
1117   params["paraty"] = SerialPort::SPACE if conf["PORT"]["paraty"].downcase == "space"
1118
1119   puts("\nPort: "+conf["PORT"]["port"]+"@"    +
1120                   params["baud"].to_s      +
1121                   " "                      +
1122                   params["data_bits"].to_s +
1123                   conf["PORT"]["paraty"][0,1].upcase +
1124                   params["stop_bits"].to_s +
1125                   "\n")
1126
1127   $sp = SerialPort.new(conf["PORT"]["port"], params)
1128
1129   $sp.read_timeout = 100; # 5 minutes
1130   $sp.flow_control = SerialPort::SOFT
1131
1132   reset_system()
1133 end
1134
1135 ################################################################################
1136 # MAIN                                                                         #
1137 ################################################################################
1138
1139 opts = Getopt::Std.getopts("r:s:f:i:a:hd")
1140
1141 conf = Hash.new
1142 conf = readconfigfile("/etc/testport.conf", conf)
1143 conf = readconfigfile("~/.testport.conf", conf)
1144 conf = readconfigfile("testport.conf", conf)
1145 conf = readconfigfile(opts["f"], conf) if opts["f"]
1146
1147 #puts conf.inspect
1148 init_serialport(conf)
1149
1150   $max_timeout = 5 * 60
1151
1152 if opts['d']
1153   $debug = true
1154 end
1155
1156 if opts['r']
1157   random_seed = opts['r'].to_i(0)
1158 else
1159   random_seed = 0xdeadbeef
1160 end
1161
1162 logfilename = conf['PORT']['testlogbase']+'bigint.txt'
1163 if File.exists?(logfilename)
1164   i=1
1165   begin
1166     logfilename = sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',i,'.txt')
1167     i+=1
1168   end while(File.exists?(logfilename))
1169   while(i>2) do
1170     n1 = sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',i-2,'.txt')
1171     n2 = sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',i-1,'.txt')
1172     File.rename(n1, n2)
1173 #    printf("%s -> %s\n", n1, n2)
1174     i-=1
1175   end
1176   n1 = sprintf('%s%s', conf['PORT']['testlogbase'],'bigint.txt')
1177   n2 = sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',1,'.txt')
1178   File.rename(n1, n2)
1179   printf("%s -> %s\n", n1, n2)
1180   logfilename = conf['PORT']['testlogbase']+'bigint.txt'
1181 end
1182 $logfile = File.open(logfilename, 'w')
1183 printf("logfile: %s\n", logfilename)
1184 $logfile.sync = true
1185 $logfile.printf("bigint test from: %s\n", Time.now.to_s)
1186 $logfile.printf("skip = %s\n", opts['s']) if opts['s']
1187 $logfile.printf("seed = 0x%X\n", random_seed)
1188
1189 tests = Hash.new
1190 tests['a'] = proc {|x| run_test_add(x) }
1191 tests['b'] = proc {|x| run_test_sub(x) }
1192 tests['d'] = proc {|x| run_test_div(x) }
1193 tests['m'] = proc {|x| run_test_mul(x) }
1194 tests['M'] = proc {|x| run_test_mulmod(x) }
1195 tests['n'] = proc {|x| run_test_mul_word(x) }
1196 tests['x'] = proc {|x| run_test_add_scale(x) }
1197 tests['s'] = proc {|x| run_test_square(x) }
1198 tests['r'] = proc {|x| run_test_reduce(x) }
1199 tests['e'] = proc {|x| run_test_expmod(x) }
1200 tests['E'] = proc {|x| run_test_expmodmont(x) }
1201 tests['g'] = proc {|x| run_test_gcdext(x) }
1202 init_str = Hash.new
1203 init_str['a'] = 'add-test'
1204 init_str['b'] = 'sub-test'
1205 init_str['d'] = 'div-test'
1206 init_str['x'] = 'add-scale-test'
1207 init_str['m'] = 'mul-test'
1208 init_str['M'] = 'mul-mont-test'
1209 init_str['n'] = 'mul-word-test'
1210 init_str['s'] = 'square-test'
1211 init_str['r'] = 'reduce-test'
1212 init_str['e'] = 'expmod-test'
1213 init_str['E'] = 'expmod-mont-test'
1214 init_str['g'] = 'gcdext-test'
1215
1216 srand(random_seed)
1217
1218 if opts['a']
1219   opts['a'].each_char do |x|
1220     if tests[x]
1221       puts init_str[x]
1222       init_system(init_str[x])
1223       tests[x].call(opts['s']?opts['s'].to_i():0)
1224     else
1225       puts "no test defined for '#{x}'"
1226     end
1227   end
1228 else
1229   'amsrMeE'.each_char do |x|
1230     if tests[x]
1231       puts init_str[x]
1232       init_system(init_str[x])
1233       tests[x].call(opts['s']?opts['s'].to_i():0)
1234     else
1235       puts "no test defined for '#{x}'"
1236     end
1237   end
1238 end
1239 1
1240
1241 $logfile.close()