← Back to branch summary

~ubuntu-branches/ubuntu/lucid/openssl/lucid-proposed

« back to all changes in this revision

Viewing changes to fips/fipsalgtest.pl

  • Committer: Bazaar Package Importer
  • Author(s): Nicolas Valcárcel Scerpella (Canonical)
  • Date: 2009-12-06 20:16:24 UTC
  • mfrom: (11.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20091206201624-u126qjpqm2n2uuhu
Tags: 0.9.8k-7ubuntu1
https://launchpad.net/bugs/493392
* Merge from debian unstable, remaining changes (LP: #493392):
  - Link using -Bsymbolic-functions
  - Add support for lpia
  - Disable SSLv2 during compile
  - Ship documentation in openssl-doc, suggested by the package.
  - Use a different priority for libssl0.9.8/restart-services
    depending on whether a desktop, or server dist-upgrade is being
    performed.
  - Display a system restart required notification bubble on libssl0.9.8
    upgrade.
  - Replace duplicate files in the doc directory with symlinks.
  - Move runtime libraries to /lib, for the benefit of wpasupplicant
* Strip the patches out of the source into quilt patches
* Disable CVE-2009-3555.patch

Show diffs side-by-side

added added

removed removed

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