* fips/fipsalgtest.pl: Test the testvectors for all the CMAC ciphers
[openssl.git] / fips / fipsalgtest.pl
1 #!/usr/bin/perl -w
2 # Perl utility to run or verify FIPS 140-2 CMVP algorithm tests based on the
3 # pathnames of input algorithm test files actually present (the unqualified
4 # file names are consistent but the pathnames are not).
5 #
6
7 # FIPS test definitions
8 # List of all the unqualified file names we expect and command lines to run
9
10 # DSA tests
11 my @fips_dsa_test_list = (
12
13     "DSA",
14
15     [ "PQGGen",  "fips_dssvs pqg" ],
16     [ "KeyPair", "fips_dssvs keypair" ],
17     [ "SigGen",  "fips_dssvs siggen" ],
18     [ "SigVer",  "fips_dssvs sigver" ]
19
20 );
21
22 my @fips_dsa_pqgver_test_list = (
23
24     [ "PQGVer",  "fips_dssvs pqgver" ]
25
26 );
27
28 # RSA tests
29
30 my @fips_rsa_test_list = (
31
32     "RSA",
33
34     [ "SigGen15",  "fips_rsastest" ],
35     [ "SigVer15",  "fips_rsavtest" ],
36     [ "SigVerRSA", "fips_rsavtest -x931" ],
37     [ "KeyGenRSA", "fips_rsagtest" ],
38     [ "SigGenRSA", "fips_rsastest -x931" ]
39
40 );
41
42 # Special cases for PSS. The filename itself is
43 # not sufficient to determine the test. Addditionally we
44 # need to examine the file contents to determine the salt length
45 # In these cases the test filename has (saltlen) appended.
46
47 # RSA PSS salt length 0 tests
48
49 my @fips_rsa_pss0_test_list = (
50
51     [ "SigGenPSS(0)", "fips_rsastest -saltlen 0" ],
52     [ "SigVerPSS(0)", "fips_rsavtest -saltlen 0" ]
53
54 );
55
56 # RSA PSS salt length 62 tests
57
58 my @fips_rsa_pss62_test_list = (
59     [ "SigGenPSS(62)", "fips_rsastest -saltlen 62" ],
60     [ "SigVerPSS(62)", "fips_rsavtest -saltlen 62" ]
61
62 );
63
64 # SHA tests
65
66 my @fips_sha_test_list = (
67
68     "SHA",
69
70     [ "SHA1LongMsg",    "fips_shatest" ],
71     [ "SHA1Monte",      "fips_shatest" ],
72     [ "SHA1ShortMsg",   "fips_shatest" ],
73     [ "SHA224LongMsg",  "fips_shatest" ],
74     [ "SHA224Monte",    "fips_shatest" ],
75     [ "SHA224ShortMsg", "fips_shatest" ],
76     [ "SHA256LongMsg",  "fips_shatest" ],
77     [ "SHA256Monte",    "fips_shatest" ],
78     [ "SHA256ShortMsg", "fips_shatest" ],
79     [ "SHA384LongMsg",  "fips_shatest" ],
80     [ "SHA384Monte",    "fips_shatest" ],
81     [ "SHA384ShortMsg", "fips_shatest" ],
82     [ "SHA512LongMsg",  "fips_shatest" ],
83     [ "SHA512Monte",    "fips_shatest" ],
84     [ "SHA512ShortMsg", "fips_shatest" ]
85
86 );
87
88 # HMAC
89
90 my @fips_hmac_test_list = (
91
92     "HMAC",
93
94     [ "HMAC", "fips_hmactest" ]
95
96 );
97
98 # CMAC
99
100 my @fips_cmac_test_list = (
101
102     "CMAC",
103
104     [ "CMACGenAES128", "fips_cmactest -a aes128 -g" ],
105     [ "CMACVerAES128", "fips_cmactest -a aes128 -v" ],
106     [ "CMACGenAES192", "fips_cmactest -a aes192 -g" ],
107     [ "CMACVerAES192", "fips_cmactest -a aes192 -v" ],
108     [ "CMACGenAES256", "fips_cmactest -a aes256 -g" ],
109     [ "CMACVerAES256", "fips_cmactest -a aes256 -v" ],
110     [ "CMACGenTDES3", "fips_cmactest -a tdes3 -g" ],
111     [ "CMACVerTDES3", "fips_cmactest -a tdes3 -v" ],
112
113 );
114
115 # RAND tests, AES version
116
117 my @fips_rand_aes_test_list = (
118
119     "RAND (AES)",
120
121     [ "ANSI931_AES128MCT", "fips_rngvs mct" ],
122     [ "ANSI931_AES192MCT", "fips_rngvs mct" ],
123     [ "ANSI931_AES256MCT", "fips_rngvs mct" ],
124     [ "ANSI931_AES128VST", "fips_rngvs vst" ],
125     [ "ANSI931_AES192VST", "fips_rngvs vst" ],
126     [ "ANSI931_AES256VST", "fips_rngvs vst" ]
127
128 );
129
130 # RAND tests, DES2 version
131
132 my @fips_rand_des2_test_list = (
133
134     "RAND (DES2)",
135
136     [ "ANSI931_TDES2MCT", "fips_rngvs mct" ],
137     [ "ANSI931_TDES2VST", "fips_rngvs vst" ]
138
139 );
140
141 # AES tests
142
143 my @fips_aes_test_list = (
144
145     "AES",
146
147     [ "CBCGFSbox128",     "fips_aesavs -f" ],
148     [ "CBCGFSbox192",     "fips_aesavs -f" ],
149     [ "CBCGFSbox256",     "fips_aesavs -f" ],
150     [ "CBCKeySbox128",    "fips_aesavs -f" ],
151     [ "CBCKeySbox192",    "fips_aesavs -f" ],
152     [ "CBCKeySbox256",    "fips_aesavs -f" ],
153     [ "CBCMCT128",        "fips_aesavs -f" ],
154     [ "CBCMCT192",        "fips_aesavs -f" ],
155     [ "CBCMCT256",        "fips_aesavs -f" ],
156     [ "CBCMMT128",        "fips_aesavs -f" ],
157     [ "CBCMMT192",        "fips_aesavs -f" ],
158     [ "CBCMMT256",        "fips_aesavs -f" ],
159     [ "CBCVarKey128",     "fips_aesavs -f" ],
160     [ "CBCVarKey192",     "fips_aesavs -f" ],
161     [ "CBCVarKey256",     "fips_aesavs -f" ],
162     [ "CBCVarTxt128",     "fips_aesavs -f" ],
163     [ "CBCVarTxt192",     "fips_aesavs -f" ],
164     [ "CBCVarTxt256",     "fips_aesavs -f" ],
165     [ "CFB128GFSbox128",  "fips_aesavs -f" ],
166     [ "CFB128GFSbox192",  "fips_aesavs -f" ],
167     [ "CFB128GFSbox256",  "fips_aesavs -f" ],
168     [ "CFB128KeySbox128", "fips_aesavs -f" ],
169     [ "CFB128KeySbox192", "fips_aesavs -f" ],
170     [ "CFB128KeySbox256", "fips_aesavs -f" ],
171     [ "CFB128MCT128",     "fips_aesavs -f" ],
172     [ "CFB128MCT192",     "fips_aesavs -f" ],
173     [ "CFB128MCT256",     "fips_aesavs -f" ],
174     [ "CFB128MMT128",     "fips_aesavs -f" ],
175     [ "CFB128MMT192",     "fips_aesavs -f" ],
176     [ "CFB128MMT256",     "fips_aesavs -f" ],
177     [ "CFB128VarKey128",  "fips_aesavs -f" ],
178     [ "CFB128VarKey192",  "fips_aesavs -f" ],
179     [ "CFB128VarKey256",  "fips_aesavs -f" ],
180     [ "CFB128VarTxt128",  "fips_aesavs -f" ],
181     [ "CFB128VarTxt192",  "fips_aesavs -f" ],
182     [ "CFB128VarTxt256",  "fips_aesavs -f" ],
183     [ "CFB8GFSbox128",    "fips_aesavs -f" ],
184     [ "CFB8GFSbox192",    "fips_aesavs -f" ],
185     [ "CFB8GFSbox256",    "fips_aesavs -f" ],
186     [ "CFB8KeySbox128",   "fips_aesavs -f" ],
187     [ "CFB8KeySbox192",   "fips_aesavs -f" ],
188     [ "CFB8KeySbox256",   "fips_aesavs -f" ],
189     [ "CFB8MCT128",       "fips_aesavs -f" ],
190     [ "CFB8MCT192",       "fips_aesavs -f" ],
191     [ "CFB8MCT256",       "fips_aesavs -f" ],
192     [ "CFB8MMT128",       "fips_aesavs -f" ],
193     [ "CFB8MMT192",       "fips_aesavs -f" ],
194     [ "CFB8MMT256",       "fips_aesavs -f" ],
195     [ "CFB8VarKey128",    "fips_aesavs -f" ],
196     [ "CFB8VarKey192",    "fips_aesavs -f" ],
197     [ "CFB8VarKey256",    "fips_aesavs -f" ],
198     [ "CFB8VarTxt128",    "fips_aesavs -f" ],
199     [ "CFB8VarTxt192",    "fips_aesavs -f" ],
200     [ "CFB8VarTxt256",    "fips_aesavs -f" ],
201
202     [ "ECBGFSbox128",  "fips_aesavs -f" ],
203     [ "ECBGFSbox192",  "fips_aesavs -f" ],
204     [ "ECBGFSbox256",  "fips_aesavs -f" ],
205     [ "ECBKeySbox128", "fips_aesavs -f" ],
206     [ "ECBKeySbox192", "fips_aesavs -f" ],
207     [ "ECBKeySbox256", "fips_aesavs -f" ],
208     [ "ECBMCT128",     "fips_aesavs -f" ],
209     [ "ECBMCT192",     "fips_aesavs -f" ],
210     [ "ECBMCT256",     "fips_aesavs -f" ],
211     [ "ECBMMT128",     "fips_aesavs -f" ],
212     [ "ECBMMT192",     "fips_aesavs -f" ],
213     [ "ECBMMT256",     "fips_aesavs -f" ],
214     [ "ECBVarKey128",  "fips_aesavs -f" ],
215     [ "ECBVarKey192",  "fips_aesavs -f" ],
216     [ "ECBVarKey256",  "fips_aesavs -f" ],
217     [ "ECBVarTxt128",  "fips_aesavs -f" ],
218     [ "ECBVarTxt192",  "fips_aesavs -f" ],
219     [ "ECBVarTxt256",  "fips_aesavs -f" ],
220     [ "OFBGFSbox128",  "fips_aesavs -f" ],
221     [ "OFBGFSbox192",  "fips_aesavs -f" ],
222     [ "OFBGFSbox256",  "fips_aesavs -f" ],
223     [ "OFBKeySbox128", "fips_aesavs -f" ],
224     [ "OFBKeySbox192", "fips_aesavs -f" ],
225     [ "OFBKeySbox256", "fips_aesavs -f" ],
226     [ "OFBMCT128",     "fips_aesavs -f" ],
227     [ "OFBMCT192",     "fips_aesavs -f" ],
228     [ "OFBMCT256",     "fips_aesavs -f" ],
229     [ "OFBMMT128",     "fips_aesavs -f" ],
230     [ "OFBMMT192",     "fips_aesavs -f" ],
231     [ "OFBMMT256",     "fips_aesavs -f" ],
232     [ "OFBVarKey128",  "fips_aesavs -f" ],
233     [ "OFBVarKey192",  "fips_aesavs -f" ],
234     [ "OFBVarKey256",  "fips_aesavs -f" ],
235     [ "OFBVarTxt128",  "fips_aesavs -f" ],
236     [ "OFBVarTxt192",  "fips_aesavs -f" ],
237     [ "OFBVarTxt256",  "fips_aesavs -f" ]
238
239 );
240
241 my @fips_aes_cfb1_test_list = (
242
243     # AES CFB1 tests
244
245     [ "CFB1GFSbox128",  "fips_aesavs -f" ],
246     [ "CFB1GFSbox192",  "fips_aesavs -f" ],
247     [ "CFB1GFSbox256",  "fips_aesavs -f" ],
248     [ "CFB1KeySbox128", "fips_aesavs -f" ],
249     [ "CFB1KeySbox192", "fips_aesavs -f" ],
250     [ "CFB1KeySbox256", "fips_aesavs -f" ],
251     [ "CFB1MCT128",     "fips_aesavs -f" ],
252     [ "CFB1MCT192",     "fips_aesavs -f" ],
253     [ "CFB1MCT256",     "fips_aesavs -f" ],
254     [ "CFB1MMT128",     "fips_aesavs -f" ],
255     [ "CFB1MMT192",     "fips_aesavs -f" ],
256     [ "CFB1MMT256",     "fips_aesavs -f" ],
257     [ "CFB1VarKey128",  "fips_aesavs -f" ],
258     [ "CFB1VarKey192",  "fips_aesavs -f" ],
259     [ "CFB1VarKey256",  "fips_aesavs -f" ],
260     [ "CFB1VarTxt128",  "fips_aesavs -f" ],
261     [ "CFB1VarTxt192",  "fips_aesavs -f" ],
262     [ "CFB1VarTxt256",  "fips_aesavs -f" ]
263
264 );
265
266 # Triple DES tests
267
268 my @fips_des3_test_list = (
269
270     "Triple DES",
271
272     [ "TCBCinvperm",   "fips_desmovs -f" ],
273     [ "TCBCMMT1",      "fips_desmovs -f" ],
274     [ "TCBCMMT2",      "fips_desmovs -f" ],
275     [ "TCBCMMT3",      "fips_desmovs -f" ],
276     [ "TCBCMonte1",    "fips_desmovs -f" ],
277     [ "TCBCMonte2",    "fips_desmovs -f" ],
278     [ "TCBCMonte3",    "fips_desmovs -f" ],
279     [ "TCBCpermop",    "fips_desmovs -f" ],
280     [ "TCBCsubtab",    "fips_desmovs -f" ],
281     [ "TCBCvarkey",    "fips_desmovs -f" ],
282     [ "TCBCvartext",   "fips_desmovs -f" ],
283     [ "TCFB64invperm", "fips_desmovs -f" ],
284     [ "TCFB64MMT1",    "fips_desmovs -f" ],
285     [ "TCFB64MMT2",    "fips_desmovs -f" ],
286     [ "TCFB64MMT3",    "fips_desmovs -f" ],
287     [ "TCFB64Monte1",  "fips_desmovs -f" ],
288     [ "TCFB64Monte2",  "fips_desmovs -f" ],
289     [ "TCFB64Monte3",  "fips_desmovs -f" ],
290     [ "TCFB64permop",  "fips_desmovs -f" ],
291     [ "TCFB64subtab",  "fips_desmovs -f" ],
292     [ "TCFB64varkey",  "fips_desmovs -f" ],
293     [ "TCFB64vartext", "fips_desmovs -f" ],
294     [ "TCFB8invperm",  "fips_desmovs -f" ],
295     [ "TCFB8MMT1",     "fips_desmovs -f" ],
296     [ "TCFB8MMT2",     "fips_desmovs -f" ],
297     [ "TCFB8MMT3",     "fips_desmovs -f" ],
298     [ "TCFB8Monte1",   "fips_desmovs -f" ],
299     [ "TCFB8Monte2",   "fips_desmovs -f" ],
300     [ "TCFB8Monte3",   "fips_desmovs -f" ],
301     [ "TCFB8permop",   "fips_desmovs -f" ],
302     [ "TCFB8subtab",   "fips_desmovs -f" ],
303     [ "TCFB8varkey",   "fips_desmovs -f" ],
304     [ "TCFB8vartext",  "fips_desmovs -f" ],
305     [ "TECBinvperm",   "fips_desmovs -f" ],
306     [ "TECBMMT1",      "fips_desmovs -f" ],
307     [ "TECBMMT2",      "fips_desmovs -f" ],
308     [ "TECBMMT3",      "fips_desmovs -f" ],
309     [ "TECBMonte1",    "fips_desmovs -f" ],
310     [ "TECBMonte2",    "fips_desmovs -f" ],
311     [ "TECBMonte3",    "fips_desmovs -f" ],
312     [ "TECBpermop",    "fips_desmovs -f" ],
313     [ "TECBsubtab",    "fips_desmovs -f" ],
314     [ "TECBvarkey",    "fips_desmovs -f" ],
315     [ "TECBvartext",   "fips_desmovs -f" ],
316     [ "TOFBinvperm",   "fips_desmovs -f" ],
317     [ "TOFBMMT1",      "fips_desmovs -f" ],
318     [ "TOFBMMT2",      "fips_desmovs -f" ],
319     [ "TOFBMMT3",      "fips_desmovs -f" ],
320     [ "TOFBMonte1",    "fips_desmovs -f" ],
321     [ "TOFBMonte2",    "fips_desmovs -f" ],
322     [ "TOFBMonte3",    "fips_desmovs -f" ],
323     [ "TOFBpermop",    "fips_desmovs -f" ],
324     [ "TOFBsubtab",    "fips_desmovs -f" ],
325     [ "TOFBvarkey",    "fips_desmovs -f" ],
326     [ "TOFBvartext",   "fips_desmovs -f" ]
327
328 );
329
330 my @fips_des3_cfb1_test_list = (
331
332     # DES3 CFB1 tests
333
334     [ "TCFB1invperm",  "fips_desmovs -f" ],
335     [ "TCFB1MMT1",     "fips_desmovs -f" ],
336     [ "TCFB1MMT2",     "fips_desmovs -f" ],
337     [ "TCFB1MMT3",     "fips_desmovs -f" ],
338     [ "TCFB1Monte1",   "fips_desmovs -f" ],
339     [ "TCFB1Monte2",   "fips_desmovs -f" ],
340     [ "TCFB1Monte3",   "fips_desmovs -f" ],
341     [ "TCFB1permop",   "fips_desmovs -f" ],
342     [ "TCFB1subtab",   "fips_desmovs -f" ],
343     [ "TCFB1varkey",   "fips_desmovs -f" ],
344     [ "TCFB1vartext",  "fips_desmovs -f" ],
345
346 );
347
348 # Verification special cases.
349 # In most cases the output of a test is deterministic and
350 # it can be compared to a known good result. A few involve
351 # the genration and use of random keys and the output will
352 # be different each time. In thoses cases we perform special tests
353 # to simply check their consistency. For example signature generation
354 # output will be run through signature verification to see if all outputs
355 # show as valid.
356 #
357
358 my %verify_special = (
359     "PQGGen"        => "fips_dssvs pqgver",
360     "KeyPair"       => "fips_dssvs keyver",
361     "SigGen"        => "fips_dssvs sigver",
362     "SigGen15"      => "fips_rsavtest",
363     "SigGenRSA"     => "fips_rsavtest -x931",
364     "SigGenPSS(0)"  => "fips_rsavtest -saltlen 0",
365     "SigGenPSS(62)" => "fips_rsavtest -saltlen 62",
366 );
367
368 my $win32  = $^O =~ m/mswin/i;
369 my $onedir = 0;
370 my $filter = "";
371 my $tvdir;
372 my $tprefix;
373 my $shwrap_prefix;
374 my $debug          = 0;
375 my $quiet          = 0;
376 my $notest         = 0;
377 my $verify         = 1;
378 my $rspdir         = "rsp";
379 my $ignore_missing = 0;
380 my $ignore_bogus   = 0;
381 my $bufout         = '';
382 my $list_tests     = 0;
383
384 my %fips_enabled = (
385     dsa         => 1,
386     "dsa-pqgver"  => 0,
387     rsa         => 1,
388     "rsa-pss0"  => 0,
389     "rsa-pss62" => 1,
390     sha         => 1,
391     hmac        => 1,
392     cmac        => 1,
393     "rand-aes"  => 1,
394     "rand-des2" => 0,
395     aes         => 1,
396     "aes-cfb1"  => 0,
397     des3        => 1,
398     "des3-cfb1" => 0
399 );
400
401 foreach (@ARGV) {
402     if ( $_ eq "--win32" ) {
403         $win32 = 1;
404     }
405     elsif ( $_ eq "--onedir" ) {
406         $onedir = 1;
407     }
408     elsif ( $_ eq "--debug" ) {
409         $debug = 1;
410     }
411     elsif ( $_ eq "--ignore-missing" ) {
412         $ignore_missing = 1;
413     }
414     elsif ( $_ eq "--ignore-bogus" ) {
415         $ignore_bogus = 1;
416     }
417     elsif ( $_ eq "--generate" ) {
418         $verify = 0;
419     }
420     elsif ( $_ eq "--notest" ) {
421         $notest = 1;
422     }
423     elsif ( $_ eq "--quiet" ) {
424         $quiet = 1;
425     }
426     elsif (/--dir=(.*)$/) {
427         $tvdir = $1;
428     }
429     elsif (/--rspdir=(.*)$/) {
430         $rspdir = $1;
431     }
432     elsif (/--tprefix=(.*)$/) {
433         $tprefix = $1;
434     }
435     elsif (/--shwrap_prefix=(.*)$/) {
436         $shwrap_prefix = $1;
437     }
438     elsif (/^--(enable|disable)-(.*)$/) {
439         if ( !exists $fips_enabled{$2} ) {
440             print STDERR "Unknown test $2\n";
441         }
442         if ( $1 eq "enable" ) {
443             $fips_enabled{$2} = 1;
444         }
445         else {
446             $fips_enabled{$2} = 0;
447         }
448     }
449     elsif (/--filter=(.*)$/) {
450         $filter = $1;
451     }
452     elsif (/^--list-tests$/) {
453         $list_tests = 1;
454     }
455     else {
456         Help();
457         exit(1);
458     }
459 }
460
461 my @fips_test_list;
462
463 push @fips_test_list, @fips_dsa_test_list       if $fips_enabled{"dsa"};
464 push @fips_test_list, @fips_dsa_pqgver_test_list if $fips_enabled{"dsa-pqgver"};
465 push @fips_test_list, @fips_rsa_test_list       if $fips_enabled{"rsa"};
466 push @fips_test_list, @fips_rsa_pss0_test_list  if $fips_enabled{"rsa-pss0"};
467 push @fips_test_list, @fips_rsa_pss62_test_list if $fips_enabled{"rsa-pss62"};
468 push @fips_test_list, @fips_sha_test_list       if $fips_enabled{"sha"};
469 push @fips_test_list, @fips_hmac_test_list      if $fips_enabled{"hmac"};
470 push @fips_test_list, @fips_cmac_test_list      if $fips_enabled{"cmac"};
471 push @fips_test_list, @fips_rand_aes_test_list  if $fips_enabled{"rand-aes"};
472 push @fips_test_list, @fips_rand_des2_test_list if $fips_enabled{"rand-des2"};
473 push @fips_test_list, @fips_aes_test_list       if $fips_enabled{"aes"};
474 push @fips_test_list, @fips_aes_cfb1_test_list  if $fips_enabled{"aes-cfb1"};
475 push @fips_test_list, @fips_des3_test_list      if $fips_enabled{"des3"};
476 push @fips_test_list, @fips_des3_cfb1_test_list if $fips_enabled{"des3-cfb1"};
477
478 if ($list_tests) {
479     my ( $test, $en );
480     print "=====TEST LIST=====\n";
481     foreach $test ( sort keys %fips_enabled ) {
482         $en = $fips_enabled{$test};
483         $test =~ tr/[a-z]/[A-Z]/;
484         printf "%-10s %s\n", $test, $en ? "enabled" : "disabled";
485     }
486     exit(0);
487 }
488
489 foreach (@fips_test_list) {
490     next unless ref($_);
491     my $nm = $_->[0];
492     $_->[2] = "";
493     $_->[3] = "";
494     print STDERR "Duplicate test $nm\n" if exists $fips_tests{$nm};
495     $fips_tests{$nm} = $_;
496 }
497
498 $tvdir = "." unless defined $tvdir;
499
500 if ($win32) {
501     if ( !defined $tprefix ) {
502         if ($onedir) {
503             $tprefix = ".\\";
504         }
505         else {
506             $tprefix = "..\\out32dll\\";
507         }
508     }
509 }
510 else {
511     if ($onedir) {
512         $tprefix       = "./" unless defined $tprefix;
513         $shwrap_prefix = "./" unless defined $shwrap_prefix;
514     }
515     else {
516         $tprefix       = "../test/" unless defined $tprefix;
517         $shwrap_prefix = "../util/" unless defined $shwrap_prefix;
518     }
519 }
520
521 sanity_check_exe( $win32, $tprefix, $shwrap_prefix );
522
523 my $cmd_prefix = $win32 ? "" : "${shwrap_prefix}shlib_wrap.sh ";
524
525 find_files( $filter, $tvdir );
526
527 sanity_check_files();
528
529 my ( $runerr, $cmperr, $cmpok, $scheckrunerr, $scheckerr, $scheckok, $skipcnt )
530   = ( 0, 0, 0, 0, 0, 0, 0 );
531
532 exit(0) if $notest;
533
534 run_tests( $verify, $win32, $tprefix, $filter, $tvdir );
535
536 if ($verify) {
537     print "ALGORITHM TEST VERIFY SUMMARY REPORT:\n";
538     print "Tests skipped due to missing files:        $skipcnt\n";
539     print "Algorithm test program execution failures: $runerr\n";
540     print "Test comparisons successful:               $cmpok\n";
541     print "Test comparisons failed:                   $cmperr\n";
542     print "Test sanity checks successful:             $scheckok\n";
543     print "Test sanity checks failed:                 $scheckerr\n";
544     print "Sanity check program execution failures:   $scheckrunerr\n";
545
546     if ( $runerr || $cmperr || $scheckrunerr || $scheckerr ) {
547         print "***TEST FAILURE***\n";
548     }
549     else {
550         print "***ALL TESTS SUCCESSFUL***\n";
551     }
552 }
553 else {
554     print "ALGORITHM TEST SUMMARY REPORT:\n";
555     print "Tests skipped due to missing files:        $skipcnt\n";
556     print "Algorithm test program execution failures: $runerr\n";
557
558     if ($runerr) {
559         print "***TEST FAILURE***\n";
560     }
561     else {
562         print "***ALL TESTS SUCCESSFUL***\n";
563     }
564 }
565
566 #--------------------------------
567 sub Help {
568     ( my $cmd ) = ( $0 =~ m#([^/]+)$# );
569     print <<EOF;
570 $cmd: generate run CMVP algorithm tests
571         --debug                     Enable debug output
572         --dir=<dirname>             Optional root for *.req file search
573         --filter=<regexp>
574         --onedir <dirname>          Assume all components in current directory
575         --rspdir=<dirname>          Name of subdirectories containing *.rsp files, default "rsp"
576         --shwrap_prefix=<prefix>
577         --tprefix=<prefix>
578         --ignore-bogus              Ignore duplicate or bogus files
579         --ignore-missing            Ignore missing test files
580         --quiet                     Shhh....
581         --generate                  Generate algorithm test output
582         --win32                     Win32 environment
583         --enable-<alg>              Enable algorithm set <alg>.
584         --disable-<alg>             Disable algorithm set <alg>.
585         Where <alg> can be one of:
586 EOF
587
588 while (my ($key, $value) = each %fips_enabled)
589         {
590         printf "\t\t%-20s(%s by default)\n", $key ,
591                         $value ? "enabled" : "disabled";
592         }
593 }
594
595 # Sanity check to see if all necessary executables exist
596
597 sub sanity_check_exe {
598     my ( $win32, $tprefix, $shwrap_prefix ) = @_;
599     my %exe_list;
600     my $bad = 0;
601     $exe_list{ $shwrap_prefix . "shlib_wrap.sh" } = 1 unless $win32;
602     foreach (@fips_test_list) {
603         next unless ref($_);
604         my $cmd = $_->[1];
605         $cmd =~ s/ .*$//;
606         $cmd = $tprefix . $cmd;
607         $cmd .= ".exe" if $win32;
608         $exe_list{$cmd} = 1;
609     }
610
611     foreach ( sort keys %exe_list ) {
612         if ( !-f $_ ) {
613             print STDERR "ERROR: can't find executable $_\n";
614             $bad = 1;
615         }
616     }
617     if ($bad) {
618         print STDERR "FATAL ERROR: executables missing\n";
619         exit(1);
620     }
621     elsif ($debug) {
622         print STDERR "Executable sanity check passed OK\n";
623     }
624 }
625
626 # Search for all request and response files
627
628 sub find_files {
629     my ( $filter, $dir ) = @_;
630     my ( $dirh, $testname );
631     opendir( $dirh, $dir );
632     while ( $_ = readdir($dirh) ) {
633         next if ( $_ eq "." || $_ eq ".." );
634         $_ = "$dir/$_";
635         if ( -f "$_" ) {
636             if (/\/([^\/]*)\.rsp$/) {
637                 $testname = fix_pss( $1, $_ );
638                 if ( exists $fips_tests{$testname} ) {
639                     if ( $fips_tests{$testname}->[3] eq "" ) {
640                         $fips_tests{$testname}->[3] = $_;
641                     }
642                     else {
643                         print STDERR
644 "WARNING: duplicate response file $_ for test $testname\n";
645                         $nbogus++;
646                     }
647                 }
648                 else {
649                     print STDERR "WARNING: bogus file $_\n";
650                     $nbogus++;
651                 }
652             }
653             next unless /$filter.*\.req$/i;
654             if (/\/([^\/]*)\.req$/) {
655                 $testname = fix_pss( $1, $_ );
656                 if ( exists $fips_tests{$testname} ) {
657                     if ( $fips_tests{$testname}->[2] eq "" ) {
658                         $fips_tests{$testname}->[2] = $_;
659                     }
660                     else {
661                         print STDERR
662 "WARNING: duplicate request file $_ for test $testname\n";
663                         $nbogus++;
664                     }
665
666                 }
667                 elsif ( !/SHAmix\.req$/ ) {
668                     print STDERR "WARNING: unrecognized filename $_\n";
669                     $nbogus++;
670                 }
671             }
672         }
673         elsif ( -d "$_" ) {
674             find_files( $filter, $_ );
675         }
676     }
677     closedir($dirh);
678 }
679
680 sub fix_pss {
681     my ( $test, $path ) = @_;
682     my $sl = "";
683     local $_;
684     if ( $test =~ /PSS/ ) {
685         open( IN, $path ) || die "Can't Open File $path";
686         while (<IN>) {
687             if (/^\s*#\s*salt\s+len:\s+(\d+)\s*$/i) {
688                 $sl = $1;
689                 last;
690             }
691         }
692         close IN;
693         if ( $sl eq "" ) {
694             print STDERR "WARNING: No Salt length detected for file $path\n";
695         }
696         else {
697             return $test . "($sl)";
698         }
699     }
700     return $test;
701 }
702
703 sub sanity_check_files {
704     my $bad = 0;
705     foreach (@fips_test_list) {
706         next unless ref($_);
707         my ( $tst, $cmd, $req, $resp ) = @$_;
708
709         #print STDERR "FILES $tst, $cmd, $req, $resp\n";
710         if ( $req eq "" ) {
711             print STDERR "WARNING: missing request file for $tst\n";
712             $bad = 1;
713             next;
714         }
715         if ( $verify && $resp eq "" ) {
716             print STDERR "WARNING: no response file for test $tst\n";
717             $bad = 1;
718         }
719         elsif ( !$verify && $resp ne "" ) {
720             print STDERR "WARNING: response file $resp will be overwritten\n";
721         }
722     }
723     if ($bad) {
724         print STDERR "ERROR: test vector file set not complete\n";
725         exit(1) unless $ignore_missing;
726     }
727     if ($nbogus) {
728         print STDERR
729           "ERROR: $nbogus bogus or duplicate request and response files\n";
730         exit(1) unless $ignore_bogus;
731     }
732     if ( $debug && !$nbogus && !$bad ) {
733         print STDERR "test vector file set complete\n";
734     }
735 }
736
737 sub run_tests {
738     my ( $verify, $win32, $tprefix, $filter, $tvdir ) = @_;
739     my ( $tname, $tref );
740     my $bad = 0;
741     foreach (@fips_test_list) {
742         if ( !ref($_) ) {
743             print "Running $_ tests\n" unless $quiet;
744             next;
745         }
746         my ( $tname, $tcmd, $req, $rsp ) = @$_;
747         my $out = $rsp;
748         if ($verify) {
749             $out =~ s/\.rsp$/.tst/;
750         }
751         if ( $req eq "" ) {
752             print STDERR
753               "WARNING: Request file for $tname missing: test skipped\n";
754             $skipcnt++;
755             next;
756         }
757         if ( $verify && $rsp eq "" ) {
758             print STDERR
759               "WARNING: Response file for $tname missing: test skipped\n";
760             $skipcnt++;
761             next;
762         }
763         elsif ( !$verify ) {
764             if ( $rsp ne "" ) {
765                 print STDERR "WARNING: Response file for $tname deleted\n";
766                 unlink $rsp;
767             }
768             $out = $req;
769             $out =~ s|/req/(\S+)\.req|/$rspdir/$1.rsp|;
770             my $outdir = $out;
771             $outdir =~ s|/[^/]*$||;
772             if ( !-d $outdir ) {
773                 print STDERR "DEBUG: Creating directory $outdir\n" if $debug;
774                 mkdir($outdir) || die "Can't create directory $outdir";
775             }
776         }
777         my $cmd = "$cmd_prefix$tprefix$tcmd ";
778         if ( $tcmd =~ /-f$/ ) {
779             $cmd .= "\"$req\" \"$out\"";
780         }
781         else {
782             $cmd .= "\"$req\" \"$out\"";
783         }
784         print STDERR "DEBUG: running test $tname\n" if ( $debug && !$verify );
785         system($cmd);
786         if ( $? != 0 ) {
787             print STDERR
788               "WARNING: error executing test $tname for command: $cmd\n";
789             $runerr++;
790             next;
791         }
792         if ($verify) {
793             if ( exists $verify_special{$tname} ) {
794                 my $vout = $rsp;
795                 $vout =~ s/\.rsp$/.ver/;
796                 $tcmd = $verify_special{$tname};
797                 $cmd  = "$cmd_prefix$tprefix$tcmd ";
798                 $cmd .= "\"$out\" \"$vout\"";
799                 system($cmd);
800                 if ( $? != 0 ) {
801                     print STDERR
802                       "WARNING: error executing verify test $tname $cmd\n";
803                     $scheckrunerr++;
804                     next;
805                 }
806                 my ( $fcount, $pcount ) = ( 0, 0 );
807                 open VER, "$vout";
808                 while (<VER>) {
809                     if (/^Result\s*=\s*(\S*)\s*$/i)
810
811                     {
812                         if ( $1 eq "F" ) {
813                             $fcount++;
814                         }
815                         else {
816                             $pcount++;
817                         }
818                     }
819                 }
820                 close VER;
821
822                 unlink $vout;
823                 if ( $fcount || $debug ) {
824                     print STDERR "DEBUG: $tname, Pass=$pcount, Fail=$fcount\n";
825                 }
826                 if ( $fcount || !$pcount ) {
827                     $scheckerr++;
828                 }
829                 else {
830                     $scheckok++;
831                 }
832
833             }
834             elsif ( !cmp_file( $tname, $rsp, $out ) ) {
835                 $cmperr++;
836             }
837             else {
838                 $cmpok++;
839             }
840             unlink $out;
841         }
842     }
843 }
844
845 sub cmp_file {
846     my ( $tname, $rsp, $tst ) = @_;
847     my ( $rspf,    $tstf );
848     my ( $rspline, $tstline );
849     if ( !open( $rspf, $rsp ) ) {
850         print STDERR "ERROR: can't open request file $rsp\n";
851         return 0;
852     }
853     if ( !open( $tstf, $tst ) ) {
854         print STDERR "ERROR: can't open output file $tst\n";
855         return 0;
856     }
857     for ( ; ; ) {
858         $rspline = next_line($rspf);
859         $tstline = next_line($tstf);
860         if ( !defined($rspline) && !defined($tstline) ) {
861             print STDERR "DEBUG: $tname file comparison OK\n" if $debug;
862             return 1;
863         }
864         if ( !defined($rspline) ) {
865             print STDERR "ERROR: $tname EOF on $rsp\n";
866             return 0;
867         }
868         if ( !defined($tstline) ) {
869             print STDERR "ERROR: $tname EOF on $tst\n";
870             return 0;
871         }
872
873         # Workaround for bug in RAND des2 test output */
874         if ( $tstline =~ /^Key2 =/ && $rspline =~ /^Key1 =/ ) {
875             $rspline =~ s/^Key1/Key2/;
876         }
877
878         if ( $tstline ne $rspline ) {
879             print STDERR "ERROR: $tname mismatch:\n";
880             print STDERR "\t \"$tstline\" != \"$rspline\"\n";
881             return 0;
882         }
883     }
884     return 1;
885 }
886
887 sub next_line {
888     my ($in) = @_;
889
890     while (<$in>) {
891         chomp;
892
893         # Delete comments
894         s/#.*$//;
895
896         # Ignore blank lines
897         next if (/^\s*$/);
898
899         # Translate multiple space into one
900         s/\s+/ /g;
901         # Delete trailing whitespace
902         s/\s+$//;
903         # Remove leading zeroes
904         s/= 00/= /;
905         # Translate to upper case
906         return uc $_;
907     }
908     return undef;
909 }