Add "OPENSSL_FIPSCAPABLE" define for a version of OpenSSL which is
[openssl.git] / fips / fipsalgtest.pl
1 #!/usr/bin/perl -w
2 # Perl utility to run or verify FIPS 140-2 CAVP 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                                         '^\s*#\s*salt\s+len:\s+0\s*$' ],
53     [ "SigVerPSS(0)", "fips_rsavtest -saltlen 0",
54                                         '^\s*#\s*salt\s+len:\s+0\s*$' ],
55
56 );
57
58 # RSA PSS salt length 62 tests
59
60 my @fips_rsa_pss62_test_list = (
61     [ "SigGenPSS(62)", "fips_rsastest -saltlen 62",
62                                         '^\s*#\s*salt\s+len:\s+62\s*$' ],
63     [ "SigVerPSS(62)", "fips_rsavtest -saltlen 62",
64                                         '^\s*#\s*salt\s+len:\s+62\s*$' ],
65 );
66
67 # SHA tests
68
69 my @fips_sha_test_list = (
70
71     "SHA",
72
73     [ "SHA1LongMsg",    "fips_shatest" ],
74     [ "SHA1Monte",      "fips_shatest" ],
75     [ "SHA1ShortMsg",   "fips_shatest" ],
76     [ "SHA224LongMsg",  "fips_shatest" ],
77     [ "SHA224Monte",    "fips_shatest" ],
78     [ "SHA224ShortMsg", "fips_shatest" ],
79     [ "SHA256LongMsg",  "fips_shatest" ],
80     [ "SHA256Monte",    "fips_shatest" ],
81     [ "SHA256ShortMsg", "fips_shatest" ],
82     [ "SHA384LongMsg",  "fips_shatest" ],
83     [ "SHA384Monte",    "fips_shatest" ],
84     [ "SHA384ShortMsg", "fips_shatest" ],
85     [ "SHA512LongMsg",  "fips_shatest" ],
86     [ "SHA512Monte",    "fips_shatest" ],
87     [ "SHA512ShortMsg", "fips_shatest" ]
88
89 );
90
91 # HMAC
92
93 my @fips_hmac_test_list = (
94
95     "HMAC",
96
97     [ "HMAC", "fips_hmactest" ]
98
99 );
100
101 # CMAC
102
103 my @fips_cmac_test_list = (
104
105     "CMAC",
106
107     [ "CMACGenAES128", "fips_cmactest -a aes128 -g" ],
108     [ "CMACVerAES128", "fips_cmactest -a aes128 -v" ],
109     [ "CMACGenAES192", "fips_cmactest -a aes192 -g" ],
110     [ "CMACVerAES192", "fips_cmactest -a aes192 -v" ],
111     [ "CMACGenAES256", "fips_cmactest -a aes256 -g" ],
112     [ "CMACVerAES256", "fips_cmactest -a aes256 -v" ],
113     [ "CMACGenTDES3", "fips_cmactest -a tdes3 -g" ],
114     [ "CMACVerTDES3", "fips_cmactest -a tdes3 -v" ],
115
116 );
117
118 # RAND tests, AES version
119
120 my @fips_rand_aes_test_list = (
121
122     "RAND (AES)",
123
124     [ "ANSI931_AES128MCT", "fips_rngvs mct" ],
125     [ "ANSI931_AES192MCT", "fips_rngvs mct" ],
126     [ "ANSI931_AES256MCT", "fips_rngvs mct" ],
127     [ "ANSI931_AES128VST", "fips_rngvs vst" ],
128     [ "ANSI931_AES192VST", "fips_rngvs vst" ],
129     [ "ANSI931_AES256VST", "fips_rngvs vst" ]
130
131 );
132
133 # RAND tests, DES2 version
134
135 my @fips_rand_des2_test_list = (
136
137     "RAND (DES2)",
138
139     [ "ANSI931_TDES2MCT", "fips_rngvs mct" ],
140     [ "ANSI931_TDES2VST", "fips_rngvs vst" ]
141
142 );
143
144 # AES tests
145
146 my @fips_aes_test_list = (
147
148     "AES",
149
150     [ "CBCGFSbox128",     "fips_aesavs -f" ],
151     [ "CBCGFSbox192",     "fips_aesavs -f" ],
152     [ "CBCGFSbox256",     "fips_aesavs -f" ],
153     [ "CBCKeySbox128",    "fips_aesavs -f" ],
154     [ "CBCKeySbox192",    "fips_aesavs -f" ],
155     [ "CBCKeySbox256",    "fips_aesavs -f" ],
156     [ "CBCMCT128",        "fips_aesavs -f" ],
157     [ "CBCMCT192",        "fips_aesavs -f" ],
158     [ "CBCMCT256",        "fips_aesavs -f" ],
159     [ "CBCMMT128",        "fips_aesavs -f" ],
160     [ "CBCMMT192",        "fips_aesavs -f" ],
161     [ "CBCMMT256",        "fips_aesavs -f" ],
162     [ "CBCVarKey128",     "fips_aesavs -f" ],
163     [ "CBCVarKey192",     "fips_aesavs -f" ],
164     [ "CBCVarKey256",     "fips_aesavs -f" ],
165     [ "CBCVarTxt128",     "fips_aesavs -f" ],
166     [ "CBCVarTxt192",     "fips_aesavs -f" ],
167     [ "CBCVarTxt256",     "fips_aesavs -f" ],
168     [ "CFB128GFSbox128",  "fips_aesavs -f" ],
169     [ "CFB128GFSbox192",  "fips_aesavs -f" ],
170     [ "CFB128GFSbox256",  "fips_aesavs -f" ],
171     [ "CFB128KeySbox128", "fips_aesavs -f" ],
172     [ "CFB128KeySbox192", "fips_aesavs -f" ],
173     [ "CFB128KeySbox256", "fips_aesavs -f" ],
174     [ "CFB128MCT128",     "fips_aesavs -f" ],
175     [ "CFB128MCT192",     "fips_aesavs -f" ],
176     [ "CFB128MCT256",     "fips_aesavs -f" ],
177     [ "CFB128MMT128",     "fips_aesavs -f" ],
178     [ "CFB128MMT192",     "fips_aesavs -f" ],
179     [ "CFB128MMT256",     "fips_aesavs -f" ],
180     [ "CFB128VarKey128",  "fips_aesavs -f" ],
181     [ "CFB128VarKey192",  "fips_aesavs -f" ],
182     [ "CFB128VarKey256",  "fips_aesavs -f" ],
183     [ "CFB128VarTxt128",  "fips_aesavs -f" ],
184     [ "CFB128VarTxt192",  "fips_aesavs -f" ],
185     [ "CFB128VarTxt256",  "fips_aesavs -f" ],
186     [ "CFB8GFSbox128",    "fips_aesavs -f" ],
187     [ "CFB8GFSbox192",    "fips_aesavs -f" ],
188     [ "CFB8GFSbox256",    "fips_aesavs -f" ],
189     [ "CFB8KeySbox128",   "fips_aesavs -f" ],
190     [ "CFB8KeySbox192",   "fips_aesavs -f" ],
191     [ "CFB8KeySbox256",   "fips_aesavs -f" ],
192     [ "CFB8MCT128",       "fips_aesavs -f" ],
193     [ "CFB8MCT192",       "fips_aesavs -f" ],
194     [ "CFB8MCT256",       "fips_aesavs -f" ],
195     [ "CFB8MMT128",       "fips_aesavs -f" ],
196     [ "CFB8MMT192",       "fips_aesavs -f" ],
197     [ "CFB8MMT256",       "fips_aesavs -f" ],
198     [ "CFB8VarKey128",    "fips_aesavs -f" ],
199     [ "CFB8VarKey192",    "fips_aesavs -f" ],
200     [ "CFB8VarKey256",    "fips_aesavs -f" ],
201     [ "CFB8VarTxt128",    "fips_aesavs -f" ],
202     [ "CFB8VarTxt192",    "fips_aesavs -f" ],
203     [ "CFB8VarTxt256",    "fips_aesavs -f" ],
204
205     [ "ECBGFSbox128",  "fips_aesavs -f" ],
206     [ "ECBGFSbox192",  "fips_aesavs -f" ],
207     [ "ECBGFSbox256",  "fips_aesavs -f" ],
208     [ "ECBKeySbox128", "fips_aesavs -f" ],
209     [ "ECBKeySbox192", "fips_aesavs -f" ],
210     [ "ECBKeySbox256", "fips_aesavs -f" ],
211     [ "ECBMCT128",     "fips_aesavs -f" ],
212     [ "ECBMCT192",     "fips_aesavs -f" ],
213     [ "ECBMCT256",     "fips_aesavs -f" ],
214     [ "ECBMMT128",     "fips_aesavs -f" ],
215     [ "ECBMMT192",     "fips_aesavs -f" ],
216     [ "ECBMMT256",     "fips_aesavs -f" ],
217     [ "ECBVarKey128",  "fips_aesavs -f" ],
218     [ "ECBVarKey192",  "fips_aesavs -f" ],
219     [ "ECBVarKey256",  "fips_aesavs -f" ],
220     [ "ECBVarTxt128",  "fips_aesavs -f" ],
221     [ "ECBVarTxt192",  "fips_aesavs -f" ],
222     [ "ECBVarTxt256",  "fips_aesavs -f" ],
223     [ "OFBGFSbox128",  "fips_aesavs -f" ],
224     [ "OFBGFSbox192",  "fips_aesavs -f" ],
225     [ "OFBGFSbox256",  "fips_aesavs -f" ],
226     [ "OFBKeySbox128", "fips_aesavs -f" ],
227     [ "OFBKeySbox192", "fips_aesavs -f" ],
228     [ "OFBKeySbox256", "fips_aesavs -f" ],
229     [ "OFBMCT128",     "fips_aesavs -f" ],
230     [ "OFBMCT192",     "fips_aesavs -f" ],
231     [ "OFBMCT256",     "fips_aesavs -f" ],
232     [ "OFBMMT128",     "fips_aesavs -f" ],
233     [ "OFBMMT192",     "fips_aesavs -f" ],
234     [ "OFBMMT256",     "fips_aesavs -f" ],
235     [ "OFBVarKey128",  "fips_aesavs -f" ],
236     [ "OFBVarKey192",  "fips_aesavs -f" ],
237     [ "OFBVarKey256",  "fips_aesavs -f" ],
238     [ "OFBVarTxt128",  "fips_aesavs -f" ],
239     [ "OFBVarTxt192",  "fips_aesavs -f" ],
240     [ "OFBVarTxt256",  "fips_aesavs -f" ]
241
242 );
243
244 my @fips_aes_cfb1_test_list = (
245
246     # AES CFB1 tests
247
248     [ "CFB1GFSbox128",  "fips_aesavs -f" ],
249     [ "CFB1GFSbox192",  "fips_aesavs -f" ],
250     [ "CFB1GFSbox256",  "fips_aesavs -f" ],
251     [ "CFB1KeySbox128", "fips_aesavs -f" ],
252     [ "CFB1KeySbox192", "fips_aesavs -f" ],
253     [ "CFB1KeySbox256", "fips_aesavs -f" ],
254     [ "CFB1MCT128",     "fips_aesavs -f" ],
255     [ "CFB1MCT192",     "fips_aesavs -f" ],
256     [ "CFB1MCT256",     "fips_aesavs -f" ],
257     [ "CFB1MMT128",     "fips_aesavs -f" ],
258     [ "CFB1MMT192",     "fips_aesavs -f" ],
259     [ "CFB1MMT256",     "fips_aesavs -f" ],
260     [ "CFB1VarKey128",  "fips_aesavs -f" ],
261     [ "CFB1VarKey192",  "fips_aesavs -f" ],
262     [ "CFB1VarKey256",  "fips_aesavs -f" ],
263     [ "CFB1VarTxt128",  "fips_aesavs -f" ],
264     [ "CFB1VarTxt192",  "fips_aesavs -f" ],
265     [ "CFB1VarTxt256",  "fips_aesavs -f" ]
266
267 );
268
269 my @fips_aes_ccm_test_list = (
270
271     # AES CCM tests
272
273     "AES CCM",
274
275     [ "DVPT128",  "fips_gcmtest -ccm" ],
276     [ "DVPT192",  "fips_gcmtest -ccm" ],
277     [ "DVPT256",  "fips_gcmtest -ccm" ],
278     [ "VADT128",  "fips_gcmtest -ccm" ],
279     [ "VADT192",  "fips_gcmtest -ccm" ],
280     [ "VADT256",  "fips_gcmtest -ccm" ],
281     [ "VNT128",  "fips_gcmtest -ccm" ],
282     [ "VNT192",  "fips_gcmtest -ccm" ],
283     [ "VNT256",  "fips_gcmtest -ccm" ],
284     [ "VPT128",  "fips_gcmtest -ccm" ],
285     [ "VPT192",  "fips_gcmtest -ccm" ],
286     [ "VPT256",  "fips_gcmtest -ccm" ],
287     [ "VTT128",  "fips_gcmtest -ccm" ],
288     [ "VTT192",  "fips_gcmtest -ccm" ],
289     [ "VTT256",  "fips_gcmtest -ccm" ]
290
291 );
292
293 my @fips_aes_gcm_test_list = (
294
295     # AES GCM tests
296
297     "AES GCM",
298
299     [ "gcmDecrypt128",  "fips_gcmtest -decrypt" ],
300     [ "gcmDecrypt192",  "fips_gcmtest -decrypt" ],
301     [ "gcmDecrypt256",  "fips_gcmtest -decrypt" ],
302
303 );
304
305 my @fips_aes_xts_test_list = (
306     # AES XTS tests
307
308     "AES XTS",
309
310     [ "XTSGenAES128",  "fips_gcmtest -xts" ],
311     [ "XTSGenAES256",  "fips_gcmtest -xts" ],
312
313 );
314
315 # Triple DES tests
316
317 my @fips_des3_test_list = (
318
319     "Triple DES",
320
321     [ "TCBCinvperm",   "fips_desmovs -f" ],
322     [ "TCBCMMT1",      "fips_desmovs -f" ],
323     [ "TCBCMMT2",      "fips_desmovs -f" ],
324     [ "TCBCMMT3",      "fips_desmovs -f" ],
325     [ "TCBCMonte1",    "fips_desmovs -f" ],
326     [ "TCBCMonte2",    "fips_desmovs -f" ],
327     [ "TCBCMonte3",    "fips_desmovs -f" ],
328     [ "TCBCpermop",    "fips_desmovs -f" ],
329     [ "TCBCsubtab",    "fips_desmovs -f" ],
330     [ "TCBCvarkey",    "fips_desmovs -f" ],
331     [ "TCBCvartext",   "fips_desmovs -f" ],
332     [ "TCFB64invperm", "fips_desmovs -f" ],
333     [ "TCFB64MMT1",    "fips_desmovs -f" ],
334     [ "TCFB64MMT2",    "fips_desmovs -f" ],
335     [ "TCFB64MMT3",    "fips_desmovs -f" ],
336     [ "TCFB64Monte1",  "fips_desmovs -f" ],
337     [ "TCFB64Monte2",  "fips_desmovs -f" ],
338     [ "TCFB64Monte3",  "fips_desmovs -f" ],
339     [ "TCFB64permop",  "fips_desmovs -f" ],
340     [ "TCFB64subtab",  "fips_desmovs -f" ],
341     [ "TCFB64varkey",  "fips_desmovs -f" ],
342     [ "TCFB64vartext", "fips_desmovs -f" ],
343     [ "TCFB8invperm",  "fips_desmovs -f" ],
344     [ "TCFB8MMT1",     "fips_desmovs -f" ],
345     [ "TCFB8MMT2",     "fips_desmovs -f" ],
346     [ "TCFB8MMT3",     "fips_desmovs -f" ],
347     [ "TCFB8Monte1",   "fips_desmovs -f" ],
348     [ "TCFB8Monte2",   "fips_desmovs -f" ],
349     [ "TCFB8Monte3",   "fips_desmovs -f" ],
350     [ "TCFB8permop",   "fips_desmovs -f" ],
351     [ "TCFB8subtab",   "fips_desmovs -f" ],
352     [ "TCFB8varkey",   "fips_desmovs -f" ],
353     [ "TCFB8vartext",  "fips_desmovs -f" ],
354     [ "TECBinvperm",   "fips_desmovs -f" ],
355     [ "TECBMMT1",      "fips_desmovs -f" ],
356     [ "TECBMMT2",      "fips_desmovs -f" ],
357     [ "TECBMMT3",      "fips_desmovs -f" ],
358     [ "TECBMonte1",    "fips_desmovs -f" ],
359     [ "TECBMonte2",    "fips_desmovs -f" ],
360     [ "TECBMonte3",    "fips_desmovs -f" ],
361     [ "TECBpermop",    "fips_desmovs -f" ],
362     [ "TECBsubtab",    "fips_desmovs -f" ],
363     [ "TECBvarkey",    "fips_desmovs -f" ],
364     [ "TECBvartext",   "fips_desmovs -f" ],
365     [ "TOFBinvperm",   "fips_desmovs -f" ],
366     [ "TOFBMMT1",      "fips_desmovs -f" ],
367     [ "TOFBMMT2",      "fips_desmovs -f" ],
368     [ "TOFBMMT3",      "fips_desmovs -f" ],
369     [ "TOFBMonte1",    "fips_desmovs -f" ],
370     [ "TOFBMonte2",    "fips_desmovs -f" ],
371     [ "TOFBMonte3",    "fips_desmovs -f" ],
372     [ "TOFBpermop",    "fips_desmovs -f" ],
373     [ "TOFBsubtab",    "fips_desmovs -f" ],
374     [ "TOFBvarkey",    "fips_desmovs -f" ],
375     [ "TOFBvartext",   "fips_desmovs -f" ]
376
377 );
378
379 my @fips_des3_cfb1_test_list = (
380
381     # DES3 CFB1 tests
382
383     [ "TCFB1invperm",  "fips_desmovs -f" ],
384     [ "TCFB1MMT1",     "fips_desmovs -f" ],
385     [ "TCFB1MMT2",     "fips_desmovs -f" ],
386     [ "TCFB1MMT3",     "fips_desmovs -f" ],
387     [ "TCFB1Monte1",   "fips_desmovs -f" ],
388     [ "TCFB1Monte2",   "fips_desmovs -f" ],
389     [ "TCFB1Monte3",   "fips_desmovs -f" ],
390     [ "TCFB1permop",   "fips_desmovs -f" ],
391     [ "TCFB1subtab",   "fips_desmovs -f" ],
392     [ "TCFB1varkey",   "fips_desmovs -f" ],
393     [ "TCFB1vartext",  "fips_desmovs -f" ],
394
395 );
396
397 my @fips_drbg_test_list = (
398
399     # SP800-90 DRBG tests
400     "SP800-90 DRBG",
401     [ "CTR_DRBG",   "fips_drbgvs" ],
402     [ "Hash_DRBG",  "fips_drbgvs" ]
403
404 );
405
406 my @fips_dh_test_list = (
407
408     # DH
409     "DH Ephemeral Primitives Only",
410     [ "KASValidityTest_FFCEphem_NOKC_ZZOnly_init",   "fips_dhvs dhver" ],
411     [ "KASValidityTest_FFCEphem_NOKC_ZZOnly_resp",   "fips_dhvs dhver" ],
412
413 );
414
415 my @fips_ecdh_test_list = (
416
417     # ECDH
418     "ECDH Ephemeral Primitives Only",
419     [ "KASValidityTest_ECCEphemeralUnified_NOKC_ZZOnly_init",
420                                                         "fips_ecdhvs ecdhver" ],
421     [ "KASValidityTest_ECCEphemeralUnified_NOKC_ZZOnly_resp",
422                                                         "fips_ecdhvs ecdhver" ],
423
424 );
425
426
427 # Verification special cases.
428 # In most cases the output of a test is deterministic and
429 # it can be compared to a known good result. A few involve
430 # the genration and use of random keys and the output will
431 # be different each time. In thoses cases we perform special tests
432 # to simply check their consistency. For example signature generation
433 # output will be run through signature verification to see if all outputs
434 # show as valid.
435 #
436
437 my %verify_special = (
438     "PQGGen"        => "fips_dssvs pqgver",
439     "KeyPair"       => "fips_dssvs keyver",
440     "SigGen"        => "fips_dssvs sigver",
441     "SigGen15"      => "fips_rsavtest",
442     "SigGenRSA"     => "fips_rsavtest -x931",
443     "SigGenPSS(0)"  => "fips_rsavtest -saltlen 0",
444     "SigGenPSS(62)" => "fips_rsavtest -saltlen 62",
445 );
446
447 my $win32  = $^O =~ m/mswin/i;
448 my $onedir = 0;
449 my $filter = "";
450 my $tvdir;
451 my $tprefix;
452 my $debug          = 0;
453 my $quiet          = 0;
454 my $notest         = 0;
455 my $verify         = 1;
456 my $rspdir         = "rsp";
457 my $ignore_missing = 0;
458 my $ignore_bogus   = 0;
459 my $bufout         = '';
460 my $list_tests     = 0;
461 my $minimal_script = 0;
462 my $outfile        = '';
463 my $no_warn_missing = 0;
464 my $no_warn_bogus = 0;
465 my $rmcmd = "rm -rf";
466 my $mkcmd = "mkdir";
467
468 my %fips_enabled = (
469     dsa         => 1,
470     "dsa-pqgver"  => 0,
471     rsa         => 1,
472     "rsa-pss0"  => 0,
473     "rsa-pss62" => 1,
474     sha         => 1,
475     hmac        => 1,
476     cmac        => 0,
477     "rand-aes"  => 1,
478     "rand-des2" => 0,
479     aes         => 1,
480     "aes-cfb1"  => 0,
481     des3        => 1,
482     "des3-cfb1" => 0,
483     drbg        => 0,
484     ccm         => 0,
485     "aes-xts"   => 0,
486     gcm         => 0,
487     dh          => 0,
488     ecdh        => 0,
489 );
490
491 foreach (@ARGV) {
492     if ( $_ eq "--win32" ) {
493         $win32 = 1;
494     }
495     elsif ( $_ eq "--onedir" ) {
496         $onedir = 1;
497     }
498     elsif ( $_ eq "--debug" ) {
499         $debug = 1;
500     }
501     elsif ( $_ eq "--quiet-missing" ) {
502         $ignore_missing = 1;
503         $no_warn_missing = 1;
504     }
505     elsif ( $_ eq "--ignore-missing" ) {
506         $ignore_missing = 1;
507     }
508     elsif ( $_ eq "--quiet-bogus" ) {
509         $ignore_bogus = 1;
510         $no_warn_bogus = 1;
511     }
512     elsif ( $_ eq "--ignore-bogus" ) {
513         $ignore_bogus = 1;
514     }
515     elsif ( $_ eq "--minimal-script" ) {
516         $minimal_script = 1;
517     }
518     elsif (/--generate-script=(.*)$/) {
519         $outfile = $1;
520         $verify = 0;
521     } elsif ( $_ eq "--generate" ) {
522         $verify = 0;
523     }
524     elsif ( $_ eq "--notest" ) {
525         $notest = 1;
526     }
527     elsif ( $_ eq "--quiet" ) {
528         $quiet = 1;
529     }
530     elsif (/--dir=(.*)$/) {
531         $tvdir = $1;
532     }
533     elsif (/--rspdir=(.*)$/) {
534         $rspdir = $1;
535     }
536     elsif (/--tprefix=(.*)$/) {
537         $tprefix = $1;
538     }
539     elsif (/^--(enable|disable)-(.*)$/) {
540         if ( !exists $fips_enabled{$2} ) {
541             print STDERR "Unknown test $2\n";
542             exit(1);
543         }
544         if ( $1 eq "enable" ) {
545             $fips_enabled{$2} = 1;
546         }
547         else {
548             $fips_enabled{$2} = 0;
549         }
550     }
551     elsif (/--filter=(.*)$/) {
552         $filter = $1;
553     }
554     elsif (/--rm=(.*)$/) {
555         $rmcmd = $1;
556     }
557     elsif (/--script-tprefix=(.*)$/) {
558         $stprefix = $1;
559     }
560     elsif (/--mkdir=(.*)$/) {
561         $mkcmd = $1;
562     }
563     elsif (/^--list-tests$/) {
564         $list_tests = 1;
565     }
566     else {
567         Help();
568         exit(1);
569     }
570 }
571
572 my @fips_test_list;
573
574 push @fips_test_list, @fips_dsa_test_list       if $fips_enabled{"dsa"};
575 push @fips_test_list, @fips_dsa_pqgver_test_list if $fips_enabled{"dsa-pqgver"};
576 push @fips_test_list, @fips_rsa_test_list       if $fips_enabled{"rsa"};
577 push @fips_test_list, @fips_rsa_pss0_test_list  if $fips_enabled{"rsa-pss0"};
578 push @fips_test_list, @fips_rsa_pss62_test_list if $fips_enabled{"rsa-pss62"};
579 push @fips_test_list, @fips_sha_test_list       if $fips_enabled{"sha"};
580 push @fips_test_list, @fips_hmac_test_list      if $fips_enabled{"hmac"};
581 push @fips_test_list, @fips_cmac_test_list      if $fips_enabled{"cmac"};
582 push @fips_test_list, @fips_rand_aes_test_list  if $fips_enabled{"rand-aes"};
583 push @fips_test_list, @fips_rand_des2_test_list if $fips_enabled{"rand-des2"};
584 push @fips_test_list, @fips_aes_test_list       if $fips_enabled{"aes"};
585 push @fips_test_list, @fips_aes_cfb1_test_list  if $fips_enabled{"aes-cfb1"};
586 push @fips_test_list, @fips_des3_test_list      if $fips_enabled{"des3"};
587 push @fips_test_list, @fips_des3_cfb1_test_list if $fips_enabled{"des3-cfb1"};
588 push @fips_test_list, @fips_drbg_test_list      if $fips_enabled{"drbg"};
589 push @fips_test_list, @fips_aes_ccm_test_list   if $fips_enabled{"aes-ccm"};
590 push @fips_test_list, @fips_aes_gcm_test_list   if $fips_enabled{"aes-gcm"};
591 push @fips_test_list, @fips_aes_xts_test_list   if $fips_enabled{"aes-xts"};
592 push @fips_test_list, @fips_dh_test_list        if $fips_enabled{"dh"};
593 push @fips_test_list, @fips_ecdh_test_list      if $fips_enabled{"ecdh"};
594
595 if ($list_tests) {
596     my ( $test, $en );
597     print "=====TEST LIST=====\n";
598     foreach $test ( sort keys %fips_enabled ) {
599         $en = $fips_enabled{$test};
600         $test =~ tr/[a-z]/[A-Z]/;
601         printf "%-10s %s\n", $test, $en ? "enabled" : "disabled";
602     }
603     exit(0);
604 }
605
606 foreach (@fips_test_list) {
607     next unless ref($_);
608     my $nm = $$_[0];
609     $$_[3] = "";
610     $$_[4] = "";
611     print STDERR "Duplicate test $nm\n" if exists $fips_tests{$nm};
612     $fips_tests{$nm} = $_;
613 }
614
615 $tvdir = "." unless defined $tvdir;
616
617 if ($win32) {
618     if ( !defined $tprefix ) {
619         if ($onedir) {
620             $tprefix = ".\\";
621         }
622         else {
623             $tprefix = "..\\out32dll\\";
624         }
625     }
626 }
627 else {
628     if ($onedir) {
629         $tprefix       = "./" unless defined $tprefix;
630     }
631     else {
632         $tprefix       = "../test/" unless defined $tprefix;
633     }
634 }
635
636 sanity_check_exe( $win32, $tprefix) if $outfile eq "";
637
638 find_files( $filter, $tvdir );
639
640 sanity_check_files();
641
642 my ( $runerr, $cmperr, $cmpok, $scheckrunerr, $scheckerr, $scheckok, $skipcnt )
643   = ( 0, 0, 0, 0, 0, 0, 0 );
644
645 exit(0) if $notest;
646 print "Outputting commands to $outfile\n" if $outfile ne "";
647 run_tests( $verify, $win32, $tprefix, $filter, $tvdir, $outfile );
648
649 if ($verify) {
650     print "ALGORITHM TEST VERIFY SUMMARY REPORT:\n";
651     print "Tests skipped due to missing files:        $skipcnt\n";
652     print "Algorithm test program execution failures: $runerr\n";
653     print "Test comparisons successful:               $cmpok\n";
654     print "Test comparisons failed:                   $cmperr\n";
655     print "Test sanity checks successful:             $scheckok\n";
656     print "Test sanity checks failed:                 $scheckerr\n";
657     print "Sanity check program execution failures:   $scheckrunerr\n";
658
659     if ( $runerr || $cmperr || $scheckrunerr || $scheckerr ) {
660         print "***TEST FAILURE***\n";
661     }
662     else {
663         print "***ALL TESTS SUCCESSFUL***\n";
664     }
665 }
666 elsif ($outfile eq "") {
667     print "ALGORITHM TEST SUMMARY REPORT:\n";
668     print "Tests skipped due to missing files:        $skipcnt\n";
669     print "Algorithm test program execution failures: $runerr\n";
670
671     if ($runerr) {
672         print "***TEST FAILURE***\n";
673     }
674     else {
675         print "***ALL TESTS SUCCESSFUL***\n";
676     }
677 }
678
679 #--------------------------------
680 sub Help {
681     ( my $cmd ) = ( $0 =~ m#([^/]+)$# );
682     print <<EOF;
683 $cmd: generate run CAVP algorithm tests
684         --debug                     Enable debug output
685         --dir=<dirname>             Optional root for *.req file search
686         --filter=<regexp>
687         --onedir <dirname>          Assume all components in current directory
688         --rspdir=<dirname>          Name of subdirectories containing *.rsp files, default "rsp"
689         --tprefix=<prefix>
690         --ignore-bogus              Ignore duplicate or bogus files
691         --ignore-missing            Ignore missing test files
692         --quiet                     Shhh....
693         --generate                  Generate algorithm test output
694         --win32                     Win32 environment
695         --enable-<alg>              Enable algorithm set <alg>.
696         --disable-<alg>             Disable algorithm set <alg>.
697         Where <alg> can be one of:
698 EOF
699
700 while (my ($key, $value) = each %fips_enabled)
701         {
702         printf "\t\t%-20s(%s by default)\n", $key ,
703                         $value ? "enabled" : "disabled";
704         }
705 }
706
707 # Sanity check to see if all necessary executables exist
708
709 sub sanity_check_exe {
710     my ( $win32, $tprefix, ) = @_;
711     my %exe_list;
712     my $bad = 0;
713     foreach (@fips_test_list) {
714         next unless ref($_);
715         my $cmd = $_->[1];
716         $cmd =~ s/ .*$//;
717         $cmd = $tprefix . $cmd;
718         $cmd .= ".exe" if $win32;
719         $exe_list{$cmd} = 1;
720     }
721
722     foreach ( sort keys %exe_list ) {
723         if ( !-f $_ ) {
724             print STDERR "ERROR: can't find executable $_\n";
725             $bad = 1;
726         }
727     }
728     if ($bad) {
729         print STDERR "FATAL ERROR: executables missing\n";
730         exit(1);
731     }
732     elsif ($debug) {
733         print STDERR "Executable sanity check passed OK\n";
734     }
735 }
736
737 # Search for all request and response files
738
739 sub find_files {
740     my ( $filter, $dir ) = @_;
741     my ( $dirh, $testname, $tref );
742     opendir( $dirh, $dir );
743     while ( $_ = readdir($dirh) ) {
744         next if ( $_ eq "." || $_ eq ".." );
745         $_ = "$dir/$_";
746         if ( -f "$_" ) {
747             if (/\/([^\/]*)\.rsp$/) {
748                 $tref = find_test($1, $_);
749                 if ( defined $tref ) {
750                     $testname = $$tref[0];
751                     if ( $$tref[4] eq "" ) {
752                         $$tref[4] = $_;
753                     }
754                     else {
755                         print STDERR
756 "WARNING: duplicate response file $_ for test $testname\n";
757                         $nbogus++;
758                     }
759                 }
760                 else {
761                     print STDERR "WARNING: bogus file $_\n" unless $no_warn_bogus;
762                     $nbogus++;
763                 }
764             }
765             next unless /$filter.*\.req$/i;
766             if (/\/([^\/]*)\.req$/) {
767                 $tref = find_test($1, $_);
768                 if ( defined $tref ) {
769                     $testname = $$tref[0];
770                     if ( $$tref[3] eq "" ) {
771                         $$tref[3] = $_;
772                     }
773                     else {
774                         print STDERR
775 "WARNING: duplicate request file $_ for test $testname\n";
776                         $nbogus++;
777                     }
778
779                 }
780                 elsif ( !/SHAmix\.req$/ ) {
781                     print STDERR "WARNING: unrecognized filename $_\n" unless $no_warn_bogus;
782                     $nbogus++;
783                 }
784             }
785         }
786         elsif ( -d "$_" ) {
787             find_files( $filter, $_ );
788         }
789     }
790     closedir($dirh);
791 }
792 #
793 # Find test based on filename.
794 # In ambiguous cases search file contents for a match
795 #
796
797 sub find_test {
798     my ( $test, $path ) = @_;
799     foreach $tref (@fips_test_list) {
800         next unless ref($tref);
801         my ( $tst, $cmd, $regexp, $req, $resp ) = @$tref;
802         $tst =~ s/\(.*$//;
803         if ($tst eq $test) {
804                 return $tref if (!defined $regexp);
805                 my $found = 0;
806                 my $line;
807                 open( IN, $path ) || die "Can't Open File $path";
808                 while ($line = <IN>) {
809                     if ($line =~ /$regexp/i) {
810                         $found = 1;
811                         last;
812                     }
813                 }
814                 close IN;
815                 return $tref if $found == 1;
816         }
817     }
818     return undef;
819 }
820
821 sub sanity_check_files {
822     my $bad = 0;
823     foreach (@fips_test_list) {
824         next unless ref($_);
825         my ( $tst, $cmd, $regexp, $req, $resp ) = @$_;
826
827         #print STDERR "FILES $tst, $cmd, $req, $resp\n";
828         if ( $req eq "" ) {
829             print STDERR "WARNING: missing request file for $tst\n" unless $no_warn_missing;
830             $bad = 1;
831             next;
832         }
833         if ( $verify && $resp eq "" ) {
834             print STDERR "WARNING: no response file for test $tst\n";
835             $bad = 1;
836         }
837         elsif ( !$verify && $resp ne "" ) {
838             print STDERR "WARNING: response file $resp will be overwritten\n";
839         }
840     }
841     if ($bad) {
842         print STDERR "ERROR: test vector file set not complete\n";
843         exit(1) unless $ignore_missing;
844     }
845     if ($nbogus) {
846         print STDERR
847           "ERROR: $nbogus bogus or duplicate request and response files\n";
848         exit(1) unless $ignore_bogus;
849     }
850     if ( $debug && !$nbogus && !$bad ) {
851         print STDERR "test vector file set complete\n";
852     }
853 }
854
855 sub run_tests {
856     my ( $verify, $win32, $tprefix, $filter, $tvdir, $outfile ) = @_;
857     my ( $tname, $tref );
858     my $bad = 0;
859     my $lastdir = "";
860     if ($outfile ne "") {
861         open OUT, ">$outfile" || die "Can't open $outfile";
862     }
863     if ($outfile ne "" && !$minimal_script) {
864         if ($win32) {
865             print OUT <<\END;
866 @echo off
867 rem Test vector run script
868 rem Auto generated by fipsalgtest.pl script
869 rem Do not edit
870
871 echo Running Algorithm Tests
872
873 END
874         } else {
875         $stprefix = $tprefix unless defined $stprefix;
876             print OUT <<END;
877 #!/bin/sh
878
879 # Test vector run script
880 # Auto generated by fipsalgtest.pl script
881 # Do not edit
882
883 echo Running Algorithm Tests
884
885 RM="$rmcmd";
886 MKDIR="$mkcmd";
887 TPREFIX=$stprefix
888
889 END
890         }
891
892     }
893
894     foreach (@fips_test_list) {
895         if ( !ref($_) ) {
896             if ($outfile ne "") {
897                 print "Generating script for $_ tests\n";
898                 print OUT "\n\n\necho \"Running $_ tests\"\n" unless $minimal_script;
899             } else {    
900                 print "Running $_ tests\n" unless $quiet;
901             }
902             next;
903         }
904         my ( $tname, $tcmd, $regexp, $req, $rsp ) = @$_;
905         my $out = $rsp;
906         if ($verify) {
907             $out =~ s/\.rsp$/.tst/;
908         }
909         if ( $req eq "" ) {
910             print STDERR
911               "WARNING: Request file for $tname missing: test skipped\n" unless $no_warn_missing;
912             $skipcnt++;
913             next;
914         }
915         if ( $verify && $rsp eq "" ) {
916             print STDERR
917               "WARNING: Response file for $tname missing: test skipped\n";
918             $skipcnt++;
919             next;
920         }
921         elsif ( !$verify ) {
922             if ( $rsp ne "" ) {
923                 print STDERR "WARNING: Response file for $tname deleted\n";
924                 unlink $rsp;
925             }
926             $out = $req;
927             $out =~ s|/req/(\S+)\.req|/$rspdir/$1.rsp|;
928             my $outdir = $out;
929             $outdir =~ s|/[^/]*$||;
930             if ($outfile ne "") {
931                 if ($win32) {
932                     $outdir =~ tr|/|\\|;
933                     $req =~ tr|/|\\|;
934                     $out =~ tr|/|\\|;
935                 }
936                 if ($outdir ne $lastdir && !$minimal_script) {
937                     if ($win32) {
938                     print OUT <<END
939 if exist \"$outdir\" rd /s /q "$outdir"
940 md \"$outdir\"
941
942 END
943                     } else {
944                     print OUT <<END
945 \$RM \"$outdir\"
946 \$MKDIR \"$outdir\"
947
948 END
949                     }
950                 $lastdir = $outdir;
951                 }
952             } elsif ( !-d $outdir ) {
953                 print STDERR "DEBUG: Creating directory $outdir\n" if $debug;
954                 mkdir($outdir) || die "Can't create directory $outdir";
955             }
956         }
957         my $cmd = "$tcmd \"$req\" \"$out\"";
958         print STDERR "DEBUG: running test $tname\n" if ( $debug && !$verify );
959         if ($outfile ne "") {
960             print OUT "echo \"    running $tname test\"\n" unless $minimal_script;
961             print OUT "\${TPREFIX}$cmd\n";
962         } else {
963             $cmd = "$tprefix$cmd";
964             system($cmd);
965             if ( $? != 0 ) {
966                 print STDERR
967                      "WARNING: error executing test $tname for command: $cmd\n";
968                 $runerr++;
969                 next;
970             }
971         }
972         if ($verify) {
973             if ( exists $verify_special{$tname} ) {
974                 my $vout = $rsp;
975                 $vout =~ s/\.rsp$/.ver/;
976                 $tcmd = $verify_special{$tname};
977                 $cmd  = "$tprefix$tcmd ";
978                 $cmd .= "\"$out\" \"$vout\"";
979                 system($cmd);
980                 if ( $? != 0 ) {
981                     print STDERR
982                       "WARNING: error executing verify test $tname $cmd\n";
983                     $scheckrunerr++;
984                     next;
985                 }
986                 my ( $fcount, $pcount ) = ( 0, 0 );
987                 open VER, "$vout";
988                 while (<VER>) {
989                     if (/^Result\s*=\s*(\S*)\s*$/i)
990
991                     {
992                         if ( $1 eq "F" ) {
993                             $fcount++;
994                         }
995                         else {
996                             $pcount++;
997                         }
998                     }
999                 }
1000                 close VER;
1001
1002                 unlink $vout;
1003                 if ( $fcount || $debug ) {
1004                     print STDERR "DEBUG: $tname, Pass=$pcount, Fail=$fcount\n";
1005                 }
1006                 if ( $fcount || !$pcount ) {
1007                     $scheckerr++;
1008                 }
1009                 else {
1010                     $scheckok++;
1011                 }
1012
1013             }
1014             elsif ( !cmp_file( $tname, $rsp, $out ) ) {
1015                 $cmperr++;
1016             }
1017             else {
1018                 $cmpok++;
1019             }
1020             unlink $out;
1021         }
1022     }
1023     if ($outfile ne "") {
1024         print OUT "\n\necho All Tests Completed\n" unless $minimal_script;
1025         close OUT;
1026     }
1027 }
1028
1029 sub cmp_file {
1030     my ( $tname, $rsp, $tst ) = @_;
1031     my ( $rspf,    $tstf );
1032     my ( $rspline, $tstline );
1033     if ( !open( $rspf, $rsp ) ) {
1034         print STDERR "ERROR: can't open request file $rsp\n";
1035         return 0;
1036     }
1037     if ( !open( $tstf, $tst ) ) {
1038         print STDERR "ERROR: can't open output file $tst\n";
1039         return 0;
1040     }
1041     for ( ; ; ) {
1042         $rspline = next_line($rspf);
1043         $tstline = next_line($tstf);
1044         if ( !defined($rspline) && !defined($tstline) ) {
1045             print STDERR "DEBUG: $tname file comparison OK\n" if $debug;
1046             return 1;
1047         }
1048         if ( !defined($rspline) ) {
1049             print STDERR "ERROR: $tname EOF on $rsp\n";
1050             return 0;
1051         }
1052         if ( !defined($tstline) ) {
1053             print STDERR "ERROR: $tname EOF on $tst\n";
1054             return 0;
1055         }
1056
1057         # Workaround for bug in RAND des2 test output */
1058         if ( $tstline =~ /^Key2 =/ && $rspline =~ /^Key1 =/ ) {
1059             $rspline =~ s/^Key1/Key2/;
1060         }
1061
1062         if ( $tstline ne $rspline ) {
1063             print STDERR "ERROR: $tname mismatch:\n";
1064             print STDERR "\t \"$tstline\" != \"$rspline\"\n";
1065             return 0;
1066         }
1067     }
1068     return 1;
1069 }
1070
1071 sub next_line {
1072     my ($in) = @_;
1073
1074     while (<$in>) {
1075         chomp;
1076
1077         # Delete comments
1078         s/#.*$//;
1079
1080         # Ignore blank lines
1081         next if (/^\s*$/);
1082
1083         # Translate multiple space into one
1084         s/\s+/ /g;
1085         # Delete trailing whitespace
1086         s/\s+$//;
1087         # Remove leading zeroes
1088         s/= 00/= /;
1089         # Translate to upper case
1090         return uc $_;
1091     }
1092     return undef;
1093 }