Fixed HMAC for SHA-384 and SHA-512 with keys longer than 64 bytes.
[libgcrypt.git] / tests / cavs_driver.pl
1 #!/usr/bin/env perl
2 #
3 # $Id: cavs_driver.pl 1243 2008-09-18 18:42:57Z smueller $
4 #
5 # CAVS test driver (based on the OpenSSL driver)
6 # Written by: Stephan Müller <sm@atsec.com>
7 # Copyright (c) atsec information security corporation
8 #
9 # Permission is hereby granted, free of charge, to any person obtaining a copy
10 # of this software and associated documentation files (the "Software"), to deal
11 # in the Software without restriction, including without limitation the rights
12 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 # copies of the Software, and to permit persons to whom the Software is
14 # furnished to do so, subject to the following conditions: 
15 #
16 # The above copyright notice and this permission notice shall be included in
17 # all copies or substantial portions of the Software.
18 #
19 #                            NO WARRANTY
20 #
21 #    BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
22 #    FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
23 #    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
24 #    PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
25 #    OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26 #    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
27 #    TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
28 #    PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
29 #    REPAIR OR CORRECTION.
30 #
31 #    IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
32 #    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
33 #    REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
34 #    INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
35 #    OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
36 #    TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
37 #    YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
38 #    PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
39 #    POSSIBILITY OF SUCH DAMAGES.
40 #
41 #
42 # test execution instruction:
43 # 1. get the request files from the lab
44 # 2. call each request file from 1. with this program:
45 #       $0 <FILE>.rep
46 # 3. send the resulting file <FILE>.rsp to the lab
47 #
48 #
49 # Test should be easily adoptable to other implementations
50 # See the first functions for this task
51 #
52 # Following tests are covered (others may also be covered
53 # but have not been tested)
54 #
55 # AES
56 #       [CBC|CFB128|ECB|OFB]GFSbox[128|192|256]
57 #       [CBC|CFB128|ECB|OFB]MCT[128|192|256]
58 #       [CBC|CFB128|ECB|OFB]VarKey[128|192|256]
59 #       [CBC|CFB128|ECB|OFB]KeySbox[128|192|256]
60 #       [CBC|CFB128|ECB|OFB]MMT[128|192|256]
61 #       [CBC|CFB128|ECB|OFB]VarTxt[128|192|256]
62 #
63 # RSA
64 #       SigGen[15|RSA]
65 #       SigVer15
66 #       (SigVerRSA is not applicable for OpenSSL as X9.31 padding
67 #               is not done through openssl dgst)
68 #
69 # SHA
70 #       SHA[1|224|256|384|512]ShortMsg
71 #       SHA[1|224|256|384|512]LongMsg
72 #       SHA[1|224|256|384|512]Monte
73 #
74 # HMAC (SHA - caveat: we only support hash output equal to the block size of
75 #       of the hash - we do not support truncation of the hash; to support
76 #       that, we first need to decipher the HMAC.req file - see hmac_kat() )
77 #       HMAC
78 #
79 # TDES
80 #       T[CBC|CFB??|ECB|OFB]Monte[1|2|3]
81 #       T[CBC|CFB??|ECB|OFB]permop
82 #       T[CBC|CFB??|ECB|OFB]MMT[1|2|3]
83 #       T[CBC|CFB??|ECB|OFB]subtab
84 #       T[CBC|CFB??|ECB|OFB]varkey
85 #       T[CBC|CFB??|ECB|OFB]invperm
86 #       T[CBC|CFB??|ECB|OFB]vartext
87 #
88 # ANSI X9.31 RNG
89 #       ANSI931_AES128MCT
90 #       ANSI931_AES128VST
91 #
92 # RC4 (atsec developed tests)
93 #       RC4KeyBD
94 #       RC4MCT
95 #       RC4PltBD
96 #       RC4REGT
97 #
98
99 use strict;
100 use warnings;
101 use IPC::Open2;
102 use Getopt::Std;
103 use MIME::Base64;
104
105 # Contains the command line options
106 my %opt;
107
108
109 #################################################################
110 ##### Central interface functions to the external ciphers #######
111 #################################################################
112 # Only these interface routines should be changed in case of
113 # porting to a new cipher library
114 #
115 # For porting to a new library, create implementation of these functions
116 # and then add pointers to the respective implementation of each
117 # function to the given variables.
118
119 # common encryption/decryption routine
120 # $1 key in hex form (please note for 3DES: even when ede3 for three
121 #    independent ciphers is given with the cipher specification, we hand in
122 #    either one key for k1 = k2 = k3, two keys which are concatinated for
123 #    k1 = k3, k2 independent, or three keys which are concatinated for
124 #    k1, k2, k3 independent)
125 # $2 iv in hex form
126 # $3 cipher - the cipher string is defined as specified in the openssl
127 #    enc(1ssl) specification for the option "-ciphername"
128 #    (e.g. aes-128-cbc or des-ede3-cbc)
129 # $4 encrypt=1/decrypt=0
130 # $5 de/encrypted data in hex form
131 # return en/decrypted data in hex form
132 my $encdec;
133
134 # Sign a message with RSA
135 # $1: data to be signed in hex form
136 # $2: Hash algo
137 # $3: Key file in PEM format with the private key
138 # return: digest in hex format
139 my $rsa_sign;
140
141 # Verify a message with RSA
142 # $1: data to be verified in hex form
143 # $2: hash algo
144 # $3: file holding the public RSA key in PEM format
145 # $4: file holding the signature in binary form
146 # return: 1 == verfied / 0 == not verified
147 my $rsa_verify;
148
149 # generate a new private RSA key with the following properties:
150 #       exponent is 65537
151 #       PEM format
152 # $1 key size in bit
153 # $2 keyfile name
154 # return: nothing, but file created
155 my $gen_rsakey;
156
157 # Creating a hash
158 # $1: Plaintext in hex form
159 # $2: hash type in the form documented in openssl's dgst(1ssl) - e.g.
160 #     sha1, sha224, sha256, sha384, sha512
161 # return: hash in hex form
162 my $hash;
163
164 # supplying the call to the external cipher implementation
165 # that is being used to keep STDIN and STDOUT open
166 # to maintain the state of the block chaining
167 # $1: cipher
168 # $2: 1=encryption, 0=decryption
169 # $3: buffersize needed for openssl
170 # $4: encryption key in binary form
171 # $5: IV in binary form
172 # return: command line to execute the application
173 my $state_cipher;
174
175 # supplying the call to the external cipher implementation
176 # that is being used to keep STDIN and STDOUT open
177 # to maintain the state of the RNG with its seed
178 #
179 # input holds seed values
180 # $1: cipher key in hex format
181 # $2: DT value in hex format
182 # $3: V value in hex format
183 #
184 # return: command line to execute the application
185 #
186 # the application is expected to deliver random values on STDOUT - the script
187 # reads 128 bits repeatedly where the state of the RNG must be retained
188 # between the reads. The output of the RNG on STDOUT is assumed to be binary.
189 my $state_rng;
190
191 # Generate an HMAC based on SHAx
192 # $1: Key to be used for the HMAC in hex format
193 # $2: length of the hash to be calculated in bits
194 # $3: Message for which the HMAC shall be calculated in hex format
195 # $4: hash type (1 - SHA1, 224 - SHA224, and so on)
196 # return: calculated HMAC in hex format
197 my $hmac;
198
199 ################################################################
200 ##### OpenSSL interface functions
201 ################################################################
202 sub openssl_encdec($$$$$) {
203         my $key=shift;
204         my $iv=shift;
205         my $cipher=shift;
206         my $enc = (shift) ? "-e" : "-d";
207         my $data=shift;
208
209         $data=hex2bin($data);
210         my $program="openssl enc -$cipher -nopad -nosalt -K $key $enc -iv $iv";
211         $program = "rc4 -k $key" if $opt{'R'}; #for ARCFOUR, no IV must be given
212         $data=pipe_through_program($data,$program);
213         return bin2hex($data);
214 }
215
216 sub openssl_rsa_sign($$$) {
217         my $data = shift;
218         my $cipher = shift;
219         my $keyfile = shift;
220
221         $data=hex2bin($data);
222         die "ARCFOUR not available for RSA" if $opt{'R'};
223         $data=pipe_through_program($data,
224                 "openssl dgst -$cipher -binary -sign $keyfile");
225         return bin2hex($data);
226 }
227
228 sub openssl_rsa_verify($$$$) {
229         my $data = shift;
230         my $cipher = shift;
231         my $keyfile = shift;
232         my $sigfile = shift;
233
234         $data = hex2bin($data);
235         die "ARCFOUR not available for RSA" if $opt{'R'};
236         $data = pipe_through_program($data,
237                 "openssl dgst -$cipher -binary -verify $keyfile -signature $sigfile");
238
239         # Parse through the OpenSSL output information
240         return ($data =~ /OK/);
241 }
242
243 sub openssl_gen_rsakey($$) {
244         my $keylen = shift;
245         my $file = shift;
246
247         die "ARCFOUR not available for RSA" if $opt{'R'};
248         # generating of a key with exponent 0x10001
249         my @args = ("openssl", "genrsa", "-F4", "-out", "$file", "$keylen");
250         system(@args) == 0
251                 or die "system @args failed: $?";
252         die "system @args failed: file $file not created" if (! -f $file);
253 }
254
255 sub openssl_hash($$) {
256         my $pt = shift;
257         my $cipher = shift;
258
259         die "ARCFOUR not available for hashes" if $opt{'R'};
260         my $hash = hex2bin($pt);
261         #bin2hex not needed as the '-hex' already converts it
262         return pipe_through_program($hash, "openssl dgst -$cipher -hex");
263 }
264
265 sub openssl_state_cipher($$$$$) {
266         my $cipher = shift;
267         my $encdec = shift;
268         my $bufsize = shift;
269         my $key = shift;
270         my $iv = shift;
271
272         my $enc = $encdec ? "-e": "-d";
273
274         my $out = "openssl enc -'$cipher' $enc -nopad -nosalt -bufsize $bufsize -K ".bin2hex($key)." -iv ".bin2hex($iv);
275         #for ARCFOUR, no IV must be given
276         $out = "rc4 -k " . bin2hex($key) if $opt{'R'};
277         return $out;
278 }
279
280 ###### End of OpenSSL interface implementation ############
281
282 ###########################################################
283 ###### libgcrypt implementation
284 ###########################################################
285 sub libgcrypt_encdec($$$$$) {
286         my $key=shift;
287         my $iv=shift;
288         my $cipher=shift;
289         my $enc = (shift) ? "encrypt" : "decrypt";
290         my $data=shift;
291
292         $iv = "--iv $iv" if ($iv);
293
294         my $program="fipsdrv --key $key $iv --algo $cipher $enc";
295
296         return pipe_through_program($data,$program);
297 }
298
299 sub libgcrypt_rsa_sign($$$) {
300         my $data = shift;
301         my $hashalgo = shift;
302         my $keyfile = shift;
303
304         die "ARCFOUR not available for RSA" if $opt{'R'};
305         return pipe_through_program($data,
306                 "fipsdrv --verbose --pkcs1 --algo $hashalgo --key $keyfile rsa-sign");
307 }
308
309 sub libgcrypt_rsa_verify($$$$) {
310         my $data = shift;
311         my $hashalgo = shift;
312         my $keyfile = shift;
313         my $sigfile = shift;
314
315         die "ARCFOUR not available for RSA" if $opt{'R'};
316         $data = pipe_through_program($data,
317                 "fipsdrv --verbose --pkcs1 --algo $hashalgo --key $keyfile --signature $sigfile rsa-verify");
318
319         # Parse through the output information
320         return ($data =~ /GOOD signature/);
321 }
322
323 sub libgcrypt_gen_rsakey($$) {
324         my $keylen = shift;
325         my $file = shift;
326
327         die "ARCFOUR not available for RSA" if $opt{'R'};
328         my @args = ("fipsdrv --keysize $keylen rsa-gen > $file");
329         system(@args) == 0
330                 or die "system @args failed: $?";
331         die "system @args failed: file $file not created" if (! -f $file);
332 }
333
334 sub libgcrypt_hash($$) {
335         my $pt = shift;
336         my $hashalgo = shift;
337
338         my $program = "fipsdrv --algo $hashalgo digest";
339         die "ARCFOUR not available for hashes" if $opt{'R'};
340
341         return pipe_through_program($pt, $program);
342 }
343
344 sub libgcrypt_state_cipher($$$$$) {
345         my $cipher = shift;
346         my $enc = (shift) ? "encrypt": "decrypt";
347         my $bufsize = shift;
348         my $key = shift;
349         my $iv = shift;
350
351         $iv = "--iv $iv" if ($iv);
352
353         my $program="fipsdrv --binary --key ".bin2hex($key)." $iv ".bin2hex($iv)." --algo '$cipher' --chunk '$bufsize' $enc";
354         return $program;
355 }
356
357 sub libgcrypt_state_rng($$$) {
358         my $key = shift;
359         my $dt = shift;
360         my $v = shift;
361
362         return "fipsdrv --binary --progress --loop --key $key --iv $v --dt $dt random";
363 }
364
365 sub libgcrypt_hmac($$$$) {
366         my $key = shift;
367         my $maclen = shift;
368         my $msg = shift;
369         my $hashtype = shift;
370
371         my $program = "fipsdrv --key $key --algo $hashtype hmac-sha";
372         return pipe_through_program($msg, $program);    
373 }
374
375 ######### End of libgcrypt implementation ################
376
377 ################################################################
378 ###### Vendor1 interface functions
379 ################################################################
380
381 sub vendor1_encdec($$$$$) {
382         my $key=shift;
383         my $iv=shift;
384         my $cipher=shift;
385         my $enc = (shift) ? "encrypt" : "decrypt";
386         my $data=shift;
387
388         $data=hex2bin($data);
389         my $program = "./aes $enc $key";
390         $data=pipe_through_program($data,$program);
391         return bin2hex($data);
392 }
393
394 sub vendor1_state_cipher($$$$$) {
395         my $cipher = shift;
396         my $encdec = shift;
397         my $bufsize = shift;
398         my $key = shift;
399         my $iv = shift;
400
401         $key = bin2hex($key);
402         my $enc = $encdec ? "encrypt": "decrypt";
403         my $out = "./aes $enc $key $bufsize";
404         return $out;
405 }
406
407 ##### No other interface functions below this point ######
408 ##########################################################
409
410 ##########################################################
411 # General helper routines
412
413 # Executing a program by feeding STDIN and retrieving
414 # STDOUT
415 # $1: data string to be piped to the app on STDIN
416 # rest: program and args
417 # returns: STDOUT of program as string
418 sub pipe_through_program($@) {
419         my $in = shift;
420         my @args = @_;
421
422         my ($CO, $CI);
423         my $pid = open2($CO, $CI, @args);
424         
425         my $out = "";
426         my $len = length($in);
427         my $first = 1;
428         while (1) {
429                 my $rin = "";
430                 my $win = "";
431                 # Output of prog is FD that we read
432                 vec($rin,fileno($CO),1) = 1;
433                 # Input of prog is FD that we write
434                 # check for $first is needed because we can have NULL input
435                 # that is to be written to the app
436                 if ( $len > 0 || $first) {
437                         (vec($win,fileno($CI),1) = 1);
438                         $first=0;
439                 }
440                 # Let us wait for 100ms
441                 my $nfound = select(my $rout=$rin, my $wout=$win, undef, 0.1);
442                 if ( $wout ) {
443                         my $written = syswrite($CI, $in, $len);
444                         die "broken pipe" if !defined $written;
445                         $len -= $written;
446                         substr($in, 0, $written) = "";
447                         if ($len <= 0) {
448                                 close $CI or die "broken pipe: $!";
449                         }
450                 }
451                 if ( $rout ) {
452                         my $tmp_out = "";
453                         my $bytes_read = sysread($CO, $tmp_out, 4096);
454                         $out .= $tmp_out;
455                         last if ($bytes_read == 0);
456                 }
457         }
458         close $CO or die "broken pipe: $!";
459         waitpid $pid, 0;
460         
461         return $out;
462 }
463
464 #
465 # convert ASCII hex to binary input
466 # $1 ASCII hex
467 # return binary representation
468 sub hex2bin($) {
469         my $in = shift;
470         my $len = length($in);
471         $len = 0 if ($in eq "00");
472         return pack("H$len", "$in");
473 }
474
475 #
476 # convert binary input to ASCII hex
477 # $1 binary value
478 # return ASCII hex representation
479 sub bin2hex($) {
480         my $in = shift;
481         my $len = length($in)*2;
482         return unpack("H$len", "$in");
483 }
484
485 # $1: binary byte (character)
486 # returns: binary byte with odd parity using low bit as parity bit
487 sub odd_par($) {
488         my $in = ord(shift);
489         my $odd_count=0;
490         for(my $i=1; $i<8; $i++) {
491                 $odd_count++ if ($in & (1<<$i));
492         }
493
494         my $out = $in;
495         if ($odd_count & 1) { # check if parity is already odd
496                 $out &= ~1; # clear the low bit
497         } else {
498                 $out |= 1; # set the low bit
499         }
500
501         return chr($out);
502 }
503
504 # DES keys uses only the 7 high bits of a byte, the 8th low bit
505 # is the parity bit
506 # as the new key is calculated from oldkey XOR cipher in the MCT test,
507 # the parity is not really checked and needs to be set to match
508 # expectation (OpenSSL does not really care, but the FIPS
509 # test result is expected that the key has the appropriate parity)
510 # $1: arbitrary binary string
511 # returns: string with odd parity set in low bit of each byte
512 sub fix_key_parity($) {
513         my $in = shift;
514         my $out = "";
515         for (my $i = 0; $i < length($in); $i++) {
516                 $out .= odd_par(substr($in, $i, 1));
517         }
518
519         return $out;
520 }
521
522 ####################################################
523 # Encrypt/Decrypt routines
524
525 # encryption
526 # $1 key in hex form
527 # $2 iv in hex form
528 # $3 cipher
529 # $4 data in hex form
530 # return encrypted data
531 sub encrypt($$$$) {
532         my $key=shift;
533         my $iv=shift;
534         my $cipher=shift;
535         my $data=shift;
536
537         return &$encdec($key, $iv, $cipher, 1, $data);
538 }
539
540 # decryption
541 # $1 key in hex form
542 # $2 iv in hex form
543 # $3 cipher
544 # $4 data in hex form
545 # return encrypted data
546 sub decrypt($$$$) {
547         my $key=shift;
548         my $iv=shift;
549         my $cipher=shift;
550         my $data=shift;
551
552         return &$encdec($key, $iv, $cipher, 0, $data);
553 }
554
555 ####################################################
556 # DER/PEM utility functions
557 # Cf. http://www.columbia.edu/~ariel/ssleay/layman.html
558
559 # Convert unsigned integer to base256 bigint bytes
560 # $1 integer
561 # returns base256 octet string
562 sub int_base256_unsigned($) {
563         my $n = shift;
564
565         my $out = chr($n & 255);
566         while ($n>>=8) {
567                 $out = chr($n & 255) . $out;
568         }
569
570         return $out;
571 }
572
573 # Convert signed integer to base256 bigint bytes
574 # $1 integer
575 # returns base256 octet string
576 sub int_base256_signed($) {
577         my $n = shift;
578         my $negative = ($n < 0);
579
580         if ($negative) {
581                 $n = -$n-1;
582         }
583
584         my $out = int_base256_unsigned($n);
585
586         if (ord(substr($out, 0, 1)) & 128) {
587                 # it's supposed to be positive but has sign bit set,
588                 # add a leading zero
589                 $out = chr(0) . $out;
590         }
591
592         if ($negative) {
593                 my $neg = chr(255) x length($out);
594                 $out ^= $neg;
595         }
596
597         return $out;
598 }
599
600 # Length header for specified DER object length
601 # $1 length as integer
602 # return octet encoding for length
603 sub der_len($) {
604         my $len = shift;
605
606         if ($len <= 127) {
607                 return chr($len);
608         } else {
609                 my $blen = int_base256_unsigned($len);
610
611                 return chr(128 | length($blen)) . $blen;
612         }
613 }
614
615 # Prepend length header to object
616 # $1 object as octet sequence
617 # return length header for object followed by object as octets
618 sub der_len_obj($) {
619         my $x = shift;
620
621         return der_len(length($x)) . $x;
622 }
623
624 # DER sequence
625 # $* objects
626 # returns DER sequence consisting of the objects passed as arguments
627 sub der_seq {
628         my $seq = join("", @_);
629         return chr(0x30) . der_len_obj($seq);
630 }
631
632 # DER bitstring
633 # $1 input octets (must be full octets, fractional octets not supported)
634 # returns input encapsulated as bitstring
635 sub der_bitstring($) {
636         my $x = shift;
637
638         $x = chr(0) . $x;
639
640         return chr(0x03) . der_len_obj($x);
641 }
642
643 # base-128-encoded integer, used for object numbers.
644 # $1 integer
645 # returns octet sequence
646 sub der_base128($) {
647         my $n = shift;
648
649         my $out = chr($n & 127);
650
651         while ($n>>=7) {
652                 $out = chr(128 | ($n & 127)) . $out;
653         }
654
655         return $out;
656 }
657
658 # Generating the PEM certificate string
659 # (base-64-encoded DER string)
660 # $1 DER string
661 # returns octet sequence
662 sub pem_cert($) {
663         my $n = shift;
664
665         my $out = "-----BEGIN PUBLIC KEY-----\n";
666         $out .= encode_base64($n);
667         $out .= "-----END PUBLIC KEY-----\n";
668
669         return $out;
670 }
671
672 # DER object identifier
673 # $* sequence of id numbers
674 # returns octets
675 sub der_objectid {
676         my $v1 = shift;
677         my $v2 = shift;
678
679         my $out = chr(40*$v1 + $v2) . join("", map { der_base128($_) } @_);
680
681         return chr(0x06) . der_len_obj($out);
682 }
683
684 # DER signed integer
685 # $1 number as octet string (base 256 representation, high byte first)
686 # returns number in DER integer encoding
687 sub der_bigint($) {
688         my $x = shift;
689
690         return chr(0x02) . der_len_obj($x);
691 }
692
693 # DER positive integer with leading zeroes stripped
694 # $1 number as octet string (base 256 representation, high byte first)
695 # returns number in DER integer encoding
696 sub der_pos_bigint($) {
697         my $x = shift;
698
699         # strip leading zero digits
700         $x =~ s/^[\0]+//;
701
702         # need to prepend a zero if high bit set, since it would otherwise be
703         # interpreted as a negative number. Also needed for number 0.
704         if (!length($x) || ord(substr($x, 0, 1)) >= 128) {
705                 $x = chr(0) . $x;
706         }
707
708         return der_bigint($x);
709 }
710
711 # $1 number as signed integer
712 # returns number as signed DER integer encoding
713 sub der_int($) {
714         my $n = shift;
715         
716         return der_bigint(int_base256_signed($n));
717 }
718
719 # the NULL object constant
720 sub der_null() {
721         return chr(0x05) . chr(0x00);
722 }
723
724 # Unit test helper
725 # $1 calculated result
726 # $2 expected result
727 # no return value, dies if results differ, showing caller's line number
728 sub der_test($$) {
729         my $actual = bin2hex(shift);
730         my $expected = shift;
731
732         my @caller = caller;
733         $actual eq $expected or die "Error:line $caller[2]:assertion failed: "
734                 ."$actual != $expected\n";
735 }
736
737 # Unit testing for the DER encoding functions
738 # Examples from http://www.columbia.edu/~ariel/ssleay/layman.html
739 # No input, no output. Dies if unit tests fail.
740 sub der_unit_test {
741         ## uncomment these if you want to test the test framework
742         #print STDERR "Unit test running\n";
743         #der_test chr(0), "42";
744
745         der_test der_null, "0500";
746
747         # length bytes
748         der_test der_len(1), "01";
749         der_test der_len(127), "7f";
750         der_test der_len(128), "8180";
751         der_test der_len(256), "820100";
752         der_test der_len(65536), "83010000";
753
754         # bigint
755         der_test der_bigint(chr(0)), "020100";
756         der_test der_bigint(chr(128)), "020180"; # -128
757         der_test der_pos_bigint(chr(128)), "02020080"; # +128
758         der_test der_pos_bigint(chr(0).chr(0).chr(1)), "020101";
759         der_test der_pos_bigint(chr(0)), "020100";
760
761         # integers (tests base256 conversion)
762         der_test der_int(     0), "020100";
763         der_test der_int(   127), "02017f";
764         der_test der_int(   128), "02020080";
765         der_test der_int(   256), "02020100";
766         der_test der_int(    -1), "0201ff";
767         der_test der_int(  -128), "020180";
768         der_test der_int(  -129), "0202ff7f";
769         der_test der_int(-65536), "0203ff0000";
770         der_test der_int(-65537), "0203feffff";
771
772         # object encoding, "RSA Security"
773         der_test der_base128(840), "8648";
774         der_test der_objectid(1, 2, 840, 113549), "06062a864886f70d";
775
776         # Combinations
777         der_test der_bitstring("ABCD"), "03050041424344";
778         der_test der_bitstring(der_null), "0303000500";
779         der_test der_seq(der_int(0), der_null), "30050201000500";
780
781         # The big picture
782         der_test der_seq(der_seq(der_objectid(1, 2, 840, 113549), der_null),
783                          der_bitstring(der_seq(der_pos_bigint(chr(5)),
784                                                der_pos_bigint(chr(3))))),
785                  "3017300a06062a864886f70d05000309003006020105020103";
786 }
787
788 ####################################################
789 # OpenSSL missing functionality workarounds
790
791 ## Format of an RSA public key:
792 #    0:d=0  hl=3 l= 159 cons: SEQUENCE          
793 #    3:d=1  hl=2 l=  13 cons:  SEQUENCE          
794 #    5:d=2  hl=2 l=   9 prim:   OBJECT            :rsaEncryption
795 #   16:d=2  hl=2 l=   0 prim:   NULL              
796 #   18:d=1  hl=3 l= 141 prim:  BIT STRING        
797 #                              [ sequence: INTEGER (n), INTEGER (e) ]
798
799 # generate RSA pub key in PEM format
800 # $1: filename where PEM key is to be stored
801 # $2: n of the RSA key in hex
802 # $3: e of the RSA key in hex
803 # return: nothing, but file created
804 sub gen_pubrsakey($$$) {
805         my $filename=shift;
806         my $n = shift;
807         my $e = shift;
808
809         # make sure the DER encoder works ;-)
810         der_unit_test();
811
812         # generate DER encoding of the public key
813
814         my $rsaEncryption = der_objectid(1, 2, 840, 113549, 1, 1, 1);
815
816         my $der = der_seq(der_seq($rsaEncryption, der_null),
817                           der_bitstring(der_seq(der_pos_bigint(hex2bin($n)),
818                                                 der_pos_bigint(hex2bin($e)))));
819
820         open(FH, ">", $filename) or die;
821         print FH pem_cert($der);
822         close FH;
823
824 }
825
826 # generate RSA pub key in PEM format
827 #
828 # This implementation uses "openssl asn1parse -genconf" which was added
829 # in openssl 0.9.8. It is not available in older openssl versions.
830 #
831 # $1: filename where PEM key is to be stored
832 # $2: n of the RSA key in hex
833 # $3: e of the RSA key in hex
834 # return: nothing, but file created
835 sub gen_pubrsakey_using_openssl($$$) {
836         my $filename=shift;
837         my $n = shift;
838         my $e = shift;
839
840         my $asn1 = "asn1=SEQUENCE:pubkeyinfo
841
842 [pubkeyinfo]
843 algorithm=SEQUENCE:rsa_alg
844 pubkey=BITWRAP,SEQUENCE:rsapubkey
845
846 [rsa_alg]
847 algorithm=OID:rsaEncryption
848 parameter=NULL
849
850 [rsapubkey]
851 n=INTEGER:0x$n
852
853 e=INTEGER:0x$e";
854
855         open(FH, ">$filename.cnf") or die "Cannot create file $filename.cnf: $?";
856         print FH $asn1;
857         close FH;
858         my @args = ("openssl", "asn1parse", "-genconf", "$filename.cnf", "-noout", "-out", "$filename.der");
859         system(@args) == 0 or die "system @args failed: $?";
860         @args = ("openssl", "rsa", "-inform", "DER", "-in", "$filename.der",
861                  "-outform", "PEM", "-pubin", "-pubout", "-out", "$filename");
862         system(@args) == 0 or die "system @args failed: $?";
863         die "RSA PEM formatted key file $filename was not created"
864                 if (! -f $filename);
865
866         unlink("$filename.cnf");
867         unlink("$filename.der");
868 }
869
870 ############################################
871 # Test cases
872
873 # This is the Known Answer Test
874 # $1: the string that we have to put in front of the key
875 #     when printing the key
876 # $2: crypto key1 in hex form
877 # $3: crypto key2 in hex form (TDES, undef otherwise)
878 # $4: crypto key3 in hex form (TDES, undef otherwise)
879 # $5: IV in hex form
880 # $6: Plaintext (enc=1) or Ciphertext (enc=0) in hex form
881 # $7: cipher
882 # $8: encrypt=1/decrypt=0
883 # return: string formatted as expected by CAVS
884 sub kat($$$$$$$$) {
885         my $keytype = shift;
886         my $key1 = shift;
887         my $key2 = shift;
888         my $key3 = shift;
889         my $iv = shift;
890         my $pt = shift;
891         my $cipher = shift;
892         my $enc = shift;
893
894         my $out = "";
895
896         $out .= "$keytype = $key1\n";
897
898         # this is the concardination of the keys for 3DES
899         if (defined($key2)) {
900                 $out .= "KEY2 = $key2\n";
901                 $key1 = $key1 . $key2;
902         }
903         if (defined($key3)) {
904                 $out .= "KEY3 = $key3\n";
905                 $key1= $key1 . $key3;
906         }
907         
908         $out .= "IV = $iv\n" if (defined($iv) && $iv ne "");
909         if ($enc) {
910                 $out .= "PLAINTEXT = $pt\n";
911                 $out .= "CIPHERTEXT = " . encrypt($key1, $iv, $cipher, $pt) . "\n";
912         } else {
913                 $out .= "CIPHERTEXT = $pt\n";
914                 $out .= "PLAINTEXT = " . decrypt($key1, $iv, $cipher, $pt) . "\n";
915         }
916
917         return $out;
918 }
919
920 # This is the Known Answer Test for Hashes
921 # $1: Plaintext in hex form
922 # $2: hash
923 # $3: hash length (undef if not applicable)
924 # return: string formatted as expected by CAVS
925 sub hash_kat($$$) {
926         my $pt = shift;
927         my $cipher = shift;
928         my $len = shift;
929
930         my $out = "";
931         $out .= "Len = $len\n" if (defined($len));
932         $out .= "Msg = $pt\n";
933         $out .= "MD = " . &$hash($pt, $cipher);
934         return $out;
935 }
936
937 # Known Answer Test for HMAC hash
938 # $1: key length in bytes
939 # $2: MAC length in bytes
940 # $3: key for HMAC in hex form
941 # $4: message to be hashed
942 # return: string formatted as expected by CAVS
943 sub hmac_kat($$$$) {
944         my $klen = shift;
945         my $tlen = shift;
946         my $key  = shift;
947         my $msg  = shift;
948
949         # XXX this is a hack - we need to decipher the HMAC REQ files in a more
950         # sane way
951         #
952         # This is a conversion table from the expected hash output size
953         # to the assumed hash type - we only define here the block size of
954         # the underlying hashes and do not allow any truncation
955         my %hashtype = (
956                 20 => 1,
957                 28 => 224,
958                 32 => 256,
959                 48 => 384,
960                 64 => 512
961         );
962
963         die "Hash output size $tlen is not supported!"
964                 if(!defined($hashtype{$tlen}));
965
966         my $out = "";
967         $out .= "Klen = $klen\n";
968         $out .= "Tlen = $tlen\n";
969         $out .= "Key = $key\n";
970         $out .= "Msg = $msg\n";
971         $out .= "Mac = " . &$hmac($key, $tlen, $msg, $hashtype{$tlen}) . "\n\n";
972
973         return $out;
974 }
975
976
977 # Cipher Monte Carlo Testing
978 # $1: the string that we have to put in front of the key
979 #     when printing the key
980 # $2: crypto key1 in hex form
981 # $3: crypto key2 in hex form (TDES, undef otherwise)
982 # $4: crypto key3 in hex form (TDES, undef otherwise)
983 # $5: IV in hex form
984 # $6: Plaintext (enc=1) or Ciphertext (enc=0) in hex form
985 # $7: cipher
986 # $8: encrypt=1/decrypt=0
987 # return: string formatted as expected by CAVS
988 sub crypto_mct($$$$$$$$) {
989         my $keytype = shift;
990         my $key1 = hex2bin(shift);
991         my $key2 = shift;
992         my $key3 = shift;
993         my $iv = hex2bin(shift);
994         my $source_data = hex2bin(shift);
995         my $cipher = shift;
996         my $enc = shift;
997
998         my $out = "";
999
1000         $key2 = hex2bin($key2) if (defined($key2));
1001         $key3 = hex2bin($key3) if (defined($key3));
1002         my $bufsize = length($source_data);
1003
1004         # for AES: outer loop 0-99, inner 0-999 based on FIPS compliance tests
1005         # for RC4: outer loop 0-99, inner 0-999 based on atsec compliance tests
1006         # for DES: outer loop 0-399, inner 0-9999 based on FIPS compliance tests
1007         my $ciph = substr($cipher,0,3);
1008         my $oloop=100;
1009         my $iloop=1000;
1010         if ($ciph =~ /des/) {$oloop=400;$iloop=10000;}
1011
1012         for (my $i=0; $i<$oloop; ++$i) {
1013                 $out .= "COUNT = $i\n";
1014                 if (defined($key2)) {
1015                         $out .= "$keytype = ". bin2hex($key1). "\n";
1016                         $out .= "KEY2 = ". bin2hex($key2). "\n";
1017                         $key1 = $key1 . $key2;
1018                 } else {
1019                         $out .= "$keytype = ". bin2hex($key1). "\n";
1020                 }
1021                 if(defined($key3)) {
1022                         $out .= "KEY3 = ". bin2hex($key3). "\n";
1023                         $key1 = $key1 . $key3;
1024                 }
1025                 my $keylen = length($key1);
1026
1027                 $out .= "IV = ". bin2hex($iv) . "\n"
1028                         if (defined($iv) && $iv ne "");
1029
1030                 if ($enc) {
1031                         $out .= "PLAINTEXT = ". bin2hex($source_data). "\n";
1032                 } else {
1033                         $out .= "CIPHERTEXT = ". bin2hex($source_data). "\n";
1034                 }
1035                 my ($CO, $CI);
1036                 my $cipher_imp = &$state_cipher($cipher, $enc, $bufsize, $key1, $iv);
1037                 my $pid = open2($CO, $CI, $cipher_imp);
1038
1039                 my $calc_data = $iv; # CT[j]
1040                 my $old_calc_data; # CT[j-1]
1041                 my $old_old_calc_data; # CT[j-2]
1042                 for (my $j = 0; $j < $iloop; ++$j) {
1043                         $old_old_calc_data = $old_calc_data;
1044                         $old_calc_data = $calc_data;
1045
1046                         # $calc_data = AES($key, $calc_data);
1047                         #print STDERR "source_data=", bin2hex($source_data), "\n";
1048                         syswrite $CI, $source_data or die;
1049                         my $len = sysread $CO, $calc_data, $bufsize;
1050                         #print STDERR "len=$len, bufsize=$bufsize\n";
1051                         die if $len ne $bufsize;
1052                         #print STDERR "calc_data=", bin2hex($calc_data), "\n";
1053
1054                         if ( (!$enc && $ciph =~ /des/) ||
1055                              $ciph =~ /rc4/ ) {
1056                                 #TDES in decryption mode and RC4 have a special rule
1057                                 $source_data = $calc_data;
1058                         } else {
1059                                 $source_data = $old_calc_data;
1060                         }
1061                 }
1062                 close $CO;
1063                 close $CI;
1064                 waitpid $pid, 0;
1065
1066                 if ($enc) {
1067                         $out .= "CIPHERTEXT = ". bin2hex($calc_data). "\n\n";
1068                 } else {
1069                         $out .= "PLAINTEXT = ". bin2hex($calc_data). "\n\n";
1070                 }
1071                 
1072                 if ( $ciph =~ /aes/ ) {
1073                         $key1 ^= substr($old_calc_data . $calc_data, -$keylen);
1074                         #print STDERR bin2hex($key1)."\n";
1075                 } elsif ( $ciph =~ /des/ ) {
1076                         die "Wrong keylen $keylen" if ($keylen != 24);
1077
1078                         # $nkey needed as $key holds the concatenation of the
1079                         # old key atm
1080                         my $nkey = fix_key_parity(substr($key1,0,8) ^ $calc_data);
1081                         #print STDERR "KEY1 = ". bin2hex($nkey)."\n";
1082                         if (substr($key1,0,8) ne substr($key1,8,8)) {
1083                                 #print STDERR "KEY2 recalc: KEY1==KEY3, KEY2 indep. or all KEYs are indep.\n";
1084                                 $key2 = fix_key_parity((substr($key1,8,8) ^ $old_calc_data));
1085                         } else {
1086                                 #print STDERR "KEY2 recalc: KEY1==KEY2==KEY3\n";
1087                                 $key2 = fix_key_parity((substr($key1,8,8) ^ $calc_data));
1088                         }
1089                         #print STDERR "KEY2 = ". bin2hex($key2)."\n";
1090                         if ( substr($key1,0,8) eq substr($key1,16)) {
1091                                 #print STDERR "KEY3 recalc: KEY1==KEY2==KEY3 or KEY1==KEY3, KEY2 indep.\n";
1092                                 $key3 = fix_key_parity((substr($key1,16) ^ $calc_data));
1093                         } else {
1094                                 #print STDERR "KEY3 recalc: all KEYs are independent\n";
1095                                 $key3 = fix_key_parity((substr($key1,16) ^ $old_old_calc_data));
1096                         }
1097                         #print STDERR "KEY3 = ". bin2hex($key3)."\n";
1098
1099                         # reset the first key - concardination happens at
1100                         # beginning of loop
1101                         $key1=$nkey;
1102                 } elsif ($ciph =~ /rc4/ ) {
1103                         $key1 ^= substr($calc_data, 0, 16);
1104                         #print STDERR bin2hex($key1)."\n";
1105                 } else {
1106                         die "Test limitation: cipher '$cipher' not supported in Monte Carlo testing";
1107                 }
1108
1109                 if (! $enc && $ciph =~ /des/ ) {
1110                         #TDES in decryption mode has a special rule
1111                         $iv = $old_calc_data;
1112                         $source_data = $calc_data;
1113                 } elsif ( $ciph =~ /rc4/ ) {
1114                         #No resetting of IV as the IV is all zero set initially (i.e. no IV)
1115                         $source_data = $calc_data;
1116                 } else {
1117                         $iv = $calc_data;
1118                         $source_data = $old_calc_data;
1119                 }
1120         }
1121
1122         return $out;
1123 }
1124
1125 # Hash Monte Carlo Testing
1126 # $1: Plaintext in hex form
1127 # $2: hash
1128 # return: string formatted as expected by CAVS
1129 sub hash_mct($$) {
1130         my $pt = shift;
1131         my $cipher = shift;
1132
1133         my $out = "";
1134
1135         $out .= "Seed = $pt\n\n";
1136         
1137         for (my $j=0; $j<100; ++$j) {
1138                 $out .= "COUNT = $j\n";
1139                 my $md0=$pt;
1140                 my $md1=$pt;
1141                 my $md2=$pt;
1142                 for (my $i=0; $i<1000; ++$i) {
1143                         my $mi= $md0 . $md1 . $md2;
1144                         $md0=$md1;
1145                         $md1=$md2;
1146                         $md2 = &$hash($mi, $cipher);
1147                         $md2 =~ s/\n//;
1148                 }
1149                 $out .= "MD = $md2\n\n";
1150                 $pt=$md2;
1151         }
1152
1153         return $out;
1154 }
1155
1156 # RSA SigGen test
1157 # $1: Message to be signed in hex form
1158 # $2: Hash algorithm
1159 # $3: file name with RSA key in PEM form
1160 # return: string formatted as expected by CAVS
1161 sub rsa_siggen($$$) {
1162         my $data = shift;
1163         my $cipher = shift;
1164         my $keyfile = shift;
1165
1166         my $out = "";
1167         
1168         $out .= "SHAAlg = $cipher\n";
1169         $out .= "Msg = $data\n";
1170         $out .= "S = " . &$rsa_sign($data, $cipher, $keyfile) . "\n";
1171
1172         return $out;
1173 }
1174
1175 # RSA SigVer test
1176 # $1: Message to be verified in hex form
1177 # $2: Hash algoritm
1178 # $3: Signature of message in hex form
1179 # $4: n of the RSA key in hex in hex form
1180 # $5: e of the RSA key in hex in hex form
1181 # return: string formatted as expected by CAVS
1182 sub rsa_sigver($$$$$) {
1183         my $data = shift;
1184         my $cipher = shift;
1185         my $signature = shift;
1186         my $n = shift;
1187         my $e = shift;
1188
1189         my $out = "";
1190
1191         $out .= "SHAAlg = $cipher\n";
1192         $out .= "e = $e\n";
1193         $out .= "Msg = $data\n";
1194         $out .= "S = $signature\n";
1195
1196         # XXX maybe a secure temp file name is better here
1197         # but since it is not run on a security sensitive
1198         # system, I hope that this is fine
1199         my $keyfile = "rsa_sigver.tmp.$$";
1200         gen_pubrsakey($keyfile, $n, $e);
1201
1202         my $sigfile = "$keyfile.sig";
1203         open(FH, ">$sigfile") or die "Cannot create file $sigfile: $?";
1204         print FH hex2bin($signature);
1205         close FH;
1206
1207         $out .= "Result = " . (&$rsa_verify($data, $cipher, $keyfile, $sigfile) ? "P\n" : "F\n");
1208
1209         unlink($keyfile);
1210         unlink($sigfile);
1211
1212         return $out;
1213 }
1214
1215 # X9.31 RNG test
1216 # $1 key for the AES cipher
1217 # $2 DT value
1218 # $3 V value
1219 # $4 type ("VST", "MCT")
1220 # return: string formatted as expected by CAVS
1221 sub rngx931($$$$) {
1222         my $key=shift;
1223         my $dt=shift;
1224         my $v=shift;
1225         my $type=shift;
1226
1227         my $out = "Key = $key\n";
1228         $out   .= "DT = $dt\n";
1229         $out   .= "V = $v\n";
1230
1231         my $count = 1;
1232         $count = 10000 if ($type eq "MCT");
1233
1234         my $rnd_val = "";
1235
1236         # we read 16 bytes from RNG
1237         my $bufsize = 16;
1238
1239         my ($CO, $CI);
1240         my $rng_imp = &$state_rng($key, $dt, $v);
1241         my $pid = open2($CO, $CI, $rng_imp);
1242         for (my $i = 0; $i < $count; ++$i) {
1243                 my $len = sysread $CO, $rnd_val, $bufsize;
1244                 #print STDERR "len=$len, bufsize=$bufsize\n";
1245                 die "len=$len != bufsize=$bufsize" if $len ne $bufsize;
1246                 #print STDERR "calc_data=", bin2hex($rnd_val), "\n";
1247         }
1248         close $CO;
1249         close $CI;
1250         waitpid $pid, 0;
1251
1252         $out .= "R = " . bin2hex($rnd_val) . "\n\n";
1253
1254         return $out;
1255 }
1256
1257 ##############################################################
1258 # Parser of input file and generator of result file
1259 #
1260
1261 sub usage() {
1262
1263         print STDERR "Usage:
1264 $0 [-R] [-I name] <CAVS-test vector file>
1265
1266 -R      execution of ARCFOUR instead of OpenSSL
1267 -I NAME Use interface style NAME:
1268                 openssl     OpenSSL (default)
1269                 libgcrypt   Libgcrypt";
1270 }
1271
1272 # Parser of CAVS test vector file
1273 # $1: Test vector file
1274 # $2: Output file for test results
1275 # return: nothing
1276 sub parse($$) {
1277         my $infile = shift;
1278         my $outfile = shift;
1279
1280         my $out = "";
1281
1282         # Do I need to generate the key?
1283         my $rsa_keygen = 0;
1284
1285         # this is my cipher/hash type
1286         my $cipher = "";
1287
1288         # Test type
1289         # 1 - cipher known answer test
1290         # 2 - cipher Monte Carlo test
1291         # 3 - hash known answer test
1292         # 4 - hash Monte Carlo test
1293         # 5 - RSA signature generation
1294         # 6 - RSA signature verification
1295         my $tt = 0;
1296
1297         # Variables for tests
1298         my $keytype = ""; # we can have "KEY", "KEYs", "KEY1"
1299         my $key1 = "";
1300         my $key2 = undef; #undef needed for allowing
1301         my $key3 = undef; #the use of them as input variables
1302         my $pt = "";
1303         my $enc = 1;
1304         my $iv = "";
1305         my $len = undef; #see key2|3
1306         my $n = "";
1307         my $e = "";
1308         my $signature = "";
1309         my $rsa_keyfile = "";
1310         my $dt = "";
1311         my $v = "";
1312         my $klen = "";
1313         my $tlen = "";
1314
1315         my $mode = "";
1316
1317         open(IN, "<$infile");
1318         while(<IN>) {
1319
1320                 my $line = $_;
1321                 chomp($line);
1322                 $line =~ s/\r//;
1323
1324                 my $keylen = "";
1325
1326                 # Mode and type check
1327                 # consider the following parsed line
1328                 # '# AESVS MCT test data for CBC'
1329                 # '# TDES Multi block Message Test for CBC'
1330                 # '# INVERSE PERMUTATION - KAT for CBC'
1331                 # '# SUBSTITUTION TABLE - KAT for CBC'
1332                 # '# TDES Monte Carlo (Modes) Test for CBC'
1333                 # '#  "SHA-1 Monte" information for "IBMRHEL5"'
1334                 # '# "SigVer PKCS#1 Ver 1.5" information for "IBMRHEL5"'
1335                 # '# "SigGen PKCS#1 Ver 1.5" information for "IBMRHEL5"'
1336                 # '#RC4VS MCT test data'
1337                 
1338                 # avoid false positives from user specified 'for "PRODUCT"' strings
1339                 my $tmpline = $line;
1340                 $tmpline =~ s/ for ".*"//;
1341
1342                 ##### Extract cipher
1343                 # XXX there may be more - to be added
1344                 if ($tmpline =~ /^#.*(CBC|ECB|OFB|CFB|SHA-|SigGen|SigVer|RC4VS|ANSI X9\.31|Hash sizes tested)/) {
1345                         if ($tmpline    =~ /CBC/)   { $mode="cbc"; }
1346                         elsif ($tmpline =~ /ECB/)   { $mode="ecb"; }
1347                         elsif ($tmpline =~ /OFB/)   { $mode="ofb"; }
1348                         elsif ($tmpline =~ /CFB/)   { $mode="cfb"; }
1349                         #we do not need mode as the cipher is already clear
1350                         elsif ($tmpline =~ /SHA-1/) { $cipher="sha1"; }
1351                         elsif ($tmpline =~ /SHA-224/) { $cipher="sha224"; }
1352                         elsif ($tmpline =~ /SHA-256/) { $cipher="sha256"; }
1353                         elsif ($tmpline =~ /SHA-384/) { $cipher="sha384"; }
1354                         elsif ($tmpline =~ /SHA-512/) { $cipher="sha512"; }
1355                         #we do not need mode as the cipher is already clear
1356                         elsif ($tmpline =~ /RC4VS/) { $cipher="rc4"; }
1357                         elsif ($tmpline =~ /SigGen|SigVer/) {
1358                                 die "Error: X9.31 is not supported"
1359                                         if ($tmpline =~ /X9/);
1360                                 $cipher="sha1"; #place holder - might be overwritten later
1361                         }
1362
1363                         # RSA Key Generation test
1364                         if ($tmpline =~ /SigGen/) {
1365                                 $rsa_keygen = 1;
1366                         }
1367                         if ($tmpline =~ /^#.*AESVS/) {
1368                                 # AES cipher (part of it)
1369                                 $cipher="aes";
1370                         }
1371                         if ($tmpline =~ /^#.*(TDES|KAT)/) {
1372                                 # TDES cipher (full definition)
1373                                 # the FIPS-140 test generator tool does not produce
1374                                 # machine readable output!
1375                                 if ($mode eq "cbc") { $cipher="des-ede3-cbc"; }
1376                                 if ($mode eq "ecb") { $cipher="des-ede3"; }
1377                                 if ($mode eq "ofb") { $cipher="des-ede3-ofb"; }
1378                                 if ($mode eq "cfb") { $cipher="des-ede3-cfb"; }
1379                         }
1380
1381                         # check for RNG
1382                         if ($tmpline =~ /ANSI X9\.31/) {
1383                                 # change the tmpline to add the type of the
1384                                 # test which is ONLY visible from the file
1385                                 # name :-(
1386                                 if ($infile =~ /MCT\.req/) {
1387                                         $tmpline .= " MCT";
1388                                 } elsif ($infile =~ /VST\.req/) {
1389                                         $tmpline .= " VST";
1390                                 } else {
1391                                         die "Unexpected cipher type with $infile";
1392                                 }
1393                         }
1394
1395
1396                         ##### Identify the test type
1397                         if ($tmpline =~ /Hash sizes tested/) {
1398                                 $tt = 9;
1399                                 die "Interface function hmac for HMAC testing not defined for tested library"
1400                                         if (!defined($hmac));
1401                         } elsif ($tmpline =~ /ANSI X9\.31/ && $tmpline =~ /MCT/) {
1402                                 $tt = 8;
1403                                 die "Interface function state_rng for RNG MCT not defined for tested library"
1404                                         if (!defined($state_rng));
1405                         } elsif ($tmpline =~ /ANSI X9\.31/ && $tmpline =~ /VST/) {
1406                                 $tt = 7;
1407                                 die "Interface function state_rng for RNG KAT not defined for tested library"
1408                                         if (!defined($state_rng));
1409                         } elsif ($tmpline =~ /SigVer/ ) {
1410                                 $tt = 6;
1411                                 die "Interface function rsa_verify or gen_rsakey for RSA verification not defined for tested library"
1412                                         if (!defined($rsa_verify) || !defined($gen_rsakey));
1413                         } elsif ($tmpline =~ /SigGen/ ) {
1414                                 $tt = 5;
1415                                 die "Interface function rsa_sign or gen_rsakey for RSA sign not defined for tested library"
1416                                         if (!defined($rsa_sign) || !defined($gen_rsakey));
1417                         } elsif ($tmpline =~ /Monte|MCT|Carlo/ && $cipher eq "sha") {
1418                                 $tt = 4;
1419                                 die "Interface function hash for Hashing not defined for tested library"
1420                                         if (!defined($hash));
1421                         } elsif ($tmpline =~ /Monte|MCT|Carlo/) {
1422                                 $tt = 2;
1423                                 die "Interface function state_cipher for Stateful Cipher operation defined for tested library"
1424                                         if (!defined($state_cipher));
1425                         } elsif ($cipher =~ /^sha\d+/ && $tt!=5 && $tt!=6) {
1426                                 $tt = 3;
1427                                 die "Interface function hash for Hashing not defined for tested library"
1428                                         if (!defined($hash));
1429                         } else {
1430                                 $tt = 1;
1431                                 die "Interface function encdec for Encryption/Decryption not defined for tested library"
1432                                         if (!defined($encdec));
1433                         }
1434                 }
1435
1436                 # This is needed as ARCFOUR does not operate with an IV
1437                 $iv = "00000000000000000000000000000000" if ($cipher eq "rc4"
1438                                                              && $iv eq "" );
1439
1440                 # we are now looking for the string
1441                 # '# Key Length : 256'
1442                 # found in AES
1443                 if ($tmpline =~ /^# Key Length.*?(128|192|256)/) {
1444                         if ($cipher eq "aes") {
1445                                 $cipher="$cipher-$1-$mode";
1446                         } else {
1447                                 die "Error: Key length $1 given for cipher $cipher which is unexpected";
1448                         }
1449                 }
1450
1451                 # Get the test data
1452                 if ($line =~ /^(KEY|KEYs|KEY1|Key)\s*=\s*(.*)/) { # found in ciphers and RNG
1453                         die "KEY seen twice - input file crap" if ($key1 ne "");
1454                         $keytype=$1;
1455                         $key1=$2;
1456                         $key1 =~ s/\s//g; #replace potential white spaces
1457                 }
1458                 elsif ($line =~ /^KEY2\s*=\s*(.*)/) { # found in TDES
1459                         die "First key not set, but got already second key - input file crap" if ($key1 eq "");
1460                         die "KEY2 seen twice - input file crap" if (defined($key2));
1461                         $key2=$1;
1462                         $key2 =~ s/\s//g; #replace potential white spaces
1463                 }
1464                 elsif ($line =~ /^KEY3\s*=\s*(.*)/) { # found in TDES
1465                         die "Second key not set, but got already third key - input file crap" if ($key2 eq "");
1466                         die "KEY3 seen twice - input file crap" if (defined($key3));
1467                         $key3=$1;
1468                         $key3 =~ s/\s//g; #replace potential white spaces
1469                 }
1470                 elsif ($line =~ /^IV\s*=\s*(.*)/) { # found in ciphers
1471                         die "IV seen twice - input file crap" if ($iv ne "");
1472                         $iv=$1;
1473                         $iv =~ s/\s//g; #replace potential white spaces
1474                 }
1475                 elsif ($line =~ /^PLAINTEXT\s*=\s*(.*)/) { # found in ciphers
1476                         if ( $1 !~ /\?/ ) { #only use it if there is valid hex data
1477                                 die "PLAINTEXT/CIPHERTEXT seen twice - input file crap" if ($pt ne "");
1478                                 $pt=$1;
1479                                 $pt =~ s/\s//g; #replace potential white spaces
1480                                 $enc=1;
1481                         }
1482                 }
1483                 elsif ($line =~ /^CIPHERTEXT\s*=\s*(.*)/) { # found in ciphers
1484                         if ( $1 !~ /\?/ ) { #only use it if there is valid hex data
1485                                 die "PLAINTEXT/CIPHERTEXT seen twice - input file crap" if ($pt ne "");
1486                                 $pt=$1;
1487                                 $pt =~ s/\s//g; #replace potential white spaces
1488                                 $enc=0;
1489                         }
1490                 }
1491                 elsif ($line =~ /^Len\s*=\s*(.*)/) { # found in hashs
1492                         $len=$1;
1493                 }
1494                 elsif ($line =~ /^(Msg|Seed)\s*=\s*(.*)/) { # found in hashs
1495                         die "Msg/Seed seen twice - input file crap" if ($pt ne "");
1496                         $pt=$2;
1497                 }
1498                 elsif ($line =~ /^\[mod\s*=\s*(.*)\]$/) { # found in RSA requests
1499                         $out .= $line . "\n"; # print it
1500                         # generate the private key with given bit length now
1501                         # as we have the required key length in bit
1502                         if ($tt == 5) {
1503                                 # XXX maybe a secure temp file name is better here
1504                                 # but since it is not run on a security sensitive
1505                                 # system, I hope that this is fine
1506                                 $rsa_keyfile = "rsa_siggen.tmp.$$";
1507                                 &$gen_rsakey($1, $rsa_keyfile);
1508                                 my $modulus = pipe_through_program("", "openssl rsa -pubout -modulus -in $rsa_keyfile");
1509                                 $modulus =~ s/Modulus=(.*?)\s(.|\s)*/$1/;
1510                                 $out .= "\nn = $modulus\n";
1511                                 $out .= "\ne = 10001\n"
1512                         }
1513                 }
1514                 elsif ($line =~ /^SHAAlg\s*=\s*(.*)/) { #found in RSA requests
1515                         $cipher=$1;
1516                 }
1517                 elsif($line =~ /^n\s*=\s*(.*)/) { # found in RSA requests
1518                         $out .= $line . "\n";
1519                         $n=$1;
1520                 }
1521                 elsif ($line =~ /^e\s*=\s*(.*)/) { # found in RSA requests
1522                         $e=$1;
1523                 }
1524                 elsif ($line =~ /^S\s*=\s*(.*)/) { # found in RSA requests
1525                         die "S seen twice - input file crap" if ($signature ne "");
1526                         $signature=$1;
1527                 }
1528                 elsif ($line =~ /^DT\s*=\s*(.*)/) { # X9.31 RNG requests
1529                         die "DT seen twice - check input file"
1530                                 if ($dt ne "");
1531                         $dt=$1;
1532                 }
1533                 elsif ($line =~ /^V\s*=\s*(.*)/) { # X9.31 RNG requests
1534                         die "V seen twice - check input file"
1535                                 if ($v ne "");
1536                         $v=$1;
1537                 }
1538                 elsif ($line =~ /^Klen\s*=\s*(.*)/) { # HMAC requests
1539                         die "Klen seen twice - check input file"
1540                                 if ($klen ne "");
1541                         $klen=$1;
1542                 }
1543                 elsif ($line =~ /^Tlen\s*=\s*(.*)/) { # HMAC RNG requests
1544                         die "Tlen seen twice - check input file"
1545                                 if ($tlen ne "");
1546                         $tlen=$1;
1547                 }
1548                 else {
1549                         $out .= $line . "\n";
1550                 }
1551
1552                 # call tests if all input data is there
1553                 if ($tt == 1) {
1554                         if ($key1 ne "" && $pt ne "" && $cipher ne "") {
1555                                 $out .= kat($keytype, $key1, $key2, $key3, $iv, $pt, $cipher, $enc);
1556                                 $keytype = "";
1557                                 $key1 = "";
1558                                 $key2 = undef;
1559                                 $key3 = undef;
1560                                 $iv = "";
1561                                 $pt = "";
1562                         }
1563                 }
1564                 elsif ($tt == 2) {
1565                         if ($key1 ne "" && $pt ne "" && $cipher ne "") {
1566                                 $out .= crypto_mct($keytype, $key1, $key2, $key3, $iv, $pt, $cipher, $enc);
1567                                 $keytype = "";
1568                                 $key1 = "";
1569                                 $key2 = undef;
1570                                 $key3 = undef;
1571                                 $iv = "";
1572                                 $pt = "";
1573                         }
1574                 }
1575                 elsif ($tt == 3) {
1576                         if ($pt ne "" && $cipher ne "") {
1577                                 $out .= hash_kat($pt, $cipher, $len);
1578                                 $pt = "";
1579                                 $len = undef;
1580                         }
1581                 }
1582                 elsif ($tt == 4) {
1583                         if ($pt ne "" && $cipher ne "") {
1584                                 $out .= hash_mct($pt, $cipher);
1585                                 $pt = "";
1586                         }
1587                 }
1588                 elsif ($tt == 5) {
1589                         if ($pt ne "" && $cipher ne "" && $rsa_keyfile ne "") {
1590                                 $out .= rsa_siggen($pt, $cipher, $rsa_keyfile);
1591                                 $pt = "";
1592                         }
1593                 }
1594                 elsif ($tt == 6) {
1595                         if ($pt ne "" && $cipher ne "" && $signature ne "" && $n ne "" && $e ne "") {
1596                                 $out .= rsa_sigver($pt, $cipher, $signature, $n, $e);
1597                                 $pt = "";
1598                                 $signature = "";
1599                         }
1600                 }
1601                 elsif ($tt == 7 ) {
1602                         if ($key1 ne "" && $dt ne "" && $v ne "") {
1603                                 $out .= rngx931($key1, $dt, $v, "VST");
1604                                 $key1 = "";
1605                                 $dt = "";
1606                                 $v = "";
1607                         }
1608                 }
1609                 elsif ($tt == 8 ) {
1610                         if ($key1 ne "" && $dt ne "" && $v ne "") {
1611                                 $out .= rngx931($key1, $dt, $v, "MCT");
1612                                 $key1 = "";
1613                                 $dt = "";
1614                                 $v = "";
1615                         }
1616                 }
1617                 elsif ($tt == 9) {
1618                         if ($klen ne "" && $tlen ne "" && $key1 ne "" && $pt ne "") {
1619                                 $out .= hmac_kat($klen, $tlen, $key1, $pt);
1620                                 $key1 = "";
1621                                 $tlen = "";
1622                                 $klen = "";
1623                                 $pt = "";
1624                         }
1625                 }
1626                 elsif ($tt > 0) {
1627                         die "Test case $tt not defined";
1628                 }
1629         }
1630
1631         close IN;
1632         $out =~ s/\n/\r\n/g; # make it a dos file
1633         open(OUT, ">$outfile") or die "Cannot create output file $outfile: $?";
1634         print OUT $out;
1635         close OUT;
1636
1637 }
1638
1639 # Signalhandler
1640 sub cleanup() {
1641         unlink("rsa_siggen.tmp.$$");
1642         unlink("rsa_sigver.tmp.$$");
1643         unlink("rsa_sigver.tmp.$$.sig");
1644         unlink("rsa_sigver.tmp.$$.der");
1645         unlink("rsa_sigver.tmp.$$.cnf");
1646         exit;
1647 }
1648
1649 ############################################################
1650 #
1651 # let us pretend to be C :-)
1652 sub main() {
1653
1654         usage() unless @ARGV;
1655
1656         getopts("RI:", \%opt) or die "bad option";
1657
1658         ##### Set library
1659
1660         if ( ! defined $opt{'I'} || $opt{'I'} eq 'openssl' ) {
1661                 print STDERR "Using OpenSSL interface functions\n";
1662                 $encdec =       \&openssl_encdec;
1663                 $rsa_sign =     \&openssl_rsa_sign;
1664                 $rsa_verify =   \&openssl_rsa_verify;
1665                 $gen_rsakey =   \&openssl_gen_rsakey;
1666                 $hash =         \&openssl_hash;
1667                 $state_cipher = \&openssl_state_cipher;
1668         } elsif ( $opt{'I'} eq 'libgcrypt' ) {
1669                 print STDERR "Using libgcrypt interface functions\n";
1670                 $encdec =       \&libgcrypt_encdec;
1671                 $rsa_sign =     \&libgcrypt_rsa_sign;
1672                 $rsa_verify =   \&libgcrypt_rsa_verify;
1673                 $gen_rsakey =   \&libgcrypt_gen_rsakey;
1674                 $hash =         \&libgcrypt_hash;
1675                 $state_cipher = \&libgcrypt_state_cipher;
1676                 $state_rng =    \&libgcrypt_state_rng;
1677                 $hmac =         \&libgcrypt_hmac;
1678         } else {
1679                 die "Invalid interface option given";
1680         }
1681
1682         my $infile=$ARGV[0];
1683         die "Error: Test vector file $infile not found" if (! -f $infile);
1684
1685         my $outfile = $infile;
1686         # let us add .rsp regardless whether we could strip .req
1687         $outfile =~ s/\.req$//;
1688         if ($opt{'R'}) {
1689                 $outfile .= ".rc4";
1690         } else {
1691                 $outfile .= ".rsp";
1692         }
1693         if (-f $outfile) {
1694                 die "Output file $outfile could not be removed: $?"
1695                         unless unlink($outfile);
1696         }
1697         print STDERR "Performing tests from source file $infile with results stored in destination file $outfile\n";
1698
1699         #Signal handler
1700         $SIG{HUP} = \&cleanup;
1701         $SIG{INT} = \&cleanup;
1702         $SIG{QUIT} = \&cleanup;
1703         $SIG{TERM} = \&cleanup;
1704
1705         # Do the job
1706         parse($infile, $outfile);
1707
1708         unlink("rsa_siggen.tmp.$$");
1709
1710 }
1711
1712 ###########################################
1713 # Call it
1714 main();
1715 1;