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