Add new private header gcrypt-testapi.h.
[libgcrypt.git] / tests / fipsdrv.c
1 /* fipsdrv.c  -  A driver to help with FIPS CAVS tests.
2    Copyright (C) 2008 Free Software Foundation, Inc.
3
4    This file is part of Libgcrypt.
5
6    Libgcrypt is free software; you can redistribute it and/or modify
7    it under the terms of the GNU Lesser General Public License as
8    published by the Free Software Foundation; either version 2.1 of
9    the License, or (at your option) any later version.
10
11    Libgcrypt is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdarg.h>
27 #include <errno.h>
28 #include <ctype.h>
29 #ifdef HAVE_W32_SYSTEM
30 # include <fcntl.h> /* We need setmode().  */
31 #else
32 # include <signal.h>
33 #endif
34 #include <assert.h>
35 #include <unistd.h>
36
37 #ifdef _GCRYPT_IN_LIBGCRYPT
38 # include "../src/gcrypt-int.h"
39 #else
40 # include <gcrypt.h>
41 # define PACKAGE_BUGREPORT "devnull@example.org"
42 # define PACKAGE_VERSION "[build on " __DATE__ " " __TIME__ "]"
43 #endif
44 #include "../src/gcrypt-testapi.h"
45
46 #define PGM "fipsdrv"
47
48 #define my_isascii(c) (!((c) & 0x80))
49 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
50 #define hexdigitp(a) (digitp (a)                     \
51                       || (*(a) >= 'A' && *(a) <= 'F')  \
52                       || (*(a) >= 'a' && *(a) <= 'f'))
53 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
54                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
55 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
56 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
57 #define DIMof(type,member)   DIM(((type *)0)->member)
58
59
60
61 /* Verbose mode flag.  */
62 static int verbose;
63
64 /* Binary input flag.  */
65 static int binary_input;
66
67 /* Binary output flag.  */
68 static int binary_output;
69
70 /* Base64 output flag.  */
71 static int base64_output;
72
73 /* We need to know whether we are in loop_mode.  */
74 static int loop_mode;
75
76 /* If true some functions are modified to print the output in the CAVS
77    response file format.  */
78 static int standalone_mode;
79
80
81 /* ASN.1 classes.  */
82 enum
83 {
84   UNIVERSAL = 0,
85   APPLICATION = 1,
86   ASNCONTEXT = 2,
87   PRIVATE = 3
88 };
89
90
91 /* ASN.1 tags.  */
92 enum
93 {
94   TAG_NONE = 0,
95   TAG_BOOLEAN = 1,
96   TAG_INTEGER = 2,
97   TAG_BIT_STRING = 3,
98   TAG_OCTET_STRING = 4,
99   TAG_NULL = 5,
100   TAG_OBJECT_ID = 6,
101   TAG_OBJECT_DESCRIPTOR = 7,
102   TAG_EXTERNAL = 8,
103   TAG_REAL = 9,
104   TAG_ENUMERATED = 10,
105   TAG_EMBEDDED_PDV = 11,
106   TAG_UTF8_STRING = 12,
107   TAG_REALTIVE_OID = 13,
108   TAG_SEQUENCE = 16,
109   TAG_SET = 17,
110   TAG_NUMERIC_STRING = 18,
111   TAG_PRINTABLE_STRING = 19,
112   TAG_TELETEX_STRING = 20,
113   TAG_VIDEOTEX_STRING = 21,
114   TAG_IA5_STRING = 22,
115   TAG_UTC_TIME = 23,
116   TAG_GENERALIZED_TIME = 24,
117   TAG_GRAPHIC_STRING = 25,
118   TAG_VISIBLE_STRING = 26,
119   TAG_GENERAL_STRING = 27,
120   TAG_UNIVERSAL_STRING = 28,
121   TAG_CHARACTER_STRING = 29,
122   TAG_BMP_STRING = 30
123 };
124
125 /* ASN.1 Parser object.  */
126 struct tag_info
127 {
128   int class;             /* Object class.  */
129   unsigned long tag;     /* The tag of the object.  */
130   unsigned long length;  /* Length of the values.  */
131   int nhdr;              /* Length of the header (TL).  */
132   unsigned int ndef:1;   /* The object has an indefinite length.  */
133   unsigned int cons:1;   /* This is a constructed object.  */
134 };
135
136
137
138 /* Print a error message and exit the process with an error code.  */
139 static void
140 die (const char *format, ...)
141 {
142   va_list arg_ptr;
143
144   va_start (arg_ptr, format);
145   fputs (PGM ": ", stderr);
146   vfprintf (stderr, format, arg_ptr);
147   va_end (arg_ptr);
148   exit (1);
149 }
150
151
152 static void
153 showhex (const char *prefix, const void *buffer, size_t length)
154 {
155   const unsigned char *p = buffer;
156
157   if (prefix)
158     fprintf (stderr, PGM ": %s: ", prefix);
159   while (length-- )
160     fprintf (stderr, "%02X", *p++);
161   if (prefix)
162     putc ('\n', stderr);
163 }
164
165 /* static void */
166 /* show_sexp (const char *prefix, gcry_sexp_t a) */
167 /* { */
168 /*   char *buf; */
169 /*   size_t size; */
170
171 /*   if (prefix) */
172 /*     fputs (prefix, stderr); */
173 /*   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0); */
174 /*   buf = gcry_xmalloc (size); */
175
176 /*   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size); */
177 /*   fprintf (stderr, "%.*s", (int)size, buf); */
178 /*   gcry_free (buf); */
179 /* } */
180
181
182 /* Convert STRING consisting of hex characters into its binary
183    representation and store that at BUFFER.  BUFFER needs to be of
184    LENGTH bytes.  The function checks that the STRING will convert
185    exactly to LENGTH bytes. The string is delimited by either end of
186    string or a white space character.  The function returns -1 on
187    error or the length of the parsed string.  */
188 static int
189 hex2bin (const char *string, void *buffer, size_t length)
190 {
191   int i;
192   const char *s = string;
193
194   for (i=0; i < length; )
195     {
196       if (!hexdigitp (s) || !hexdigitp (s+1))
197         return -1;           /* Invalid hex digits. */
198       ((unsigned char*)buffer)[i++] = xtoi_2 (s);
199       s += 2;
200     }
201   if (*s && (!my_isascii (*s) || !isspace (*s)) )
202     return -1;             /* Not followed by Nul or white space.  */
203   if (i != length)
204     return -1;             /* Not of expected length.  */
205   if (*s)
206     s++; /* Skip the delimiter. */
207   return s - string;
208 }
209
210
211 /* Convert STRING consisting of hex characters into its binary
212    representation and return it as an allocated buffer. The valid
213    length of the buffer is returned at R_LENGTH.  The string is
214    delimited by end of string.  The function returns NULL on
215    error.  */
216 static void *
217 hex2buffer (const char *string, size_t *r_length)
218 {
219   const char *s;
220   unsigned char *buffer;
221   size_t length;
222
223   buffer = gcry_xmalloc (strlen(string)/2+1);
224   length = 0;
225   for (s=string; *s; s +=2 )
226     {
227       if (!hexdigitp (s) || !hexdigitp (s+1))
228         return NULL;           /* Invalid hex digits. */
229       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
230     }
231   *r_length = length;
232   return buffer;
233 }
234
235
236 static char *
237 read_textline (FILE *fp)
238 {
239   char line[256];
240   char *p;
241   int any = 0;
242
243   /* Read line but skip over initial empty lines.  */
244   do
245     {
246       do
247         {
248           if (!fgets (line, sizeof line, fp))
249             {
250               if (feof (fp))
251                 return NULL;
252               die ("error reading input line: %s\n", strerror (errno));
253             }
254           p = strchr (line, '\n');
255           if (p)
256             *p = 0;
257           p = line + (*line? (strlen (line)-1):0);
258           for ( ;p > line; p--)
259             if (my_isascii (*p) && isspace (*p))
260               *p = 0;
261         }
262       while (!any && !*line);
263       any = 1;
264     }
265   while (*line == '#');  /* Always skip comment lines.  */
266   if (verbose > 1)
267     fprintf (stderr, PGM ": received line: %s\n", line);
268   return gcry_xstrdup (line);
269 }
270
271 static char *
272 read_hexline (FILE *fp, size_t *retlen)
273 {
274   char *line, *p;
275
276   line = read_textline (fp);
277   if (!line)
278     return NULL;
279   p = hex2buffer (line, retlen);
280   if (!p)
281     die ("error decoding hex string on input\n");
282   gcry_free (line);
283   return p;
284 }
285
286 static void
287 skip_to_empty_line (FILE *fp)
288 {
289   char line[256];
290   char *p;
291
292   do
293     {
294       if (!fgets (line, sizeof line, fp))
295         {
296           if (feof (fp))
297             return;
298           die ("error reading input line: %s\n", strerror (errno));
299         }
300       p = strchr (line, '\n');
301       if (p)
302         *p =0;
303     }
304   while (*line);
305 }
306
307
308
309 /* Read a file from stream FP into a newly allocated buffer and return
310    that buffer.  The valid length of the buffer is stored at R_LENGTH.
311    Returns NULL on failure.  If decode is set, the file is assumed to
312    be hex encoded and the decoded content is returned. */
313 static void *
314 read_file (FILE *fp, int decode, size_t *r_length)
315 {
316   char *buffer;
317   size_t buflen;
318   size_t nread, bufsize = 0;
319
320   *r_length = 0;
321 #define NCHUNK 8192
322 #ifdef HAVE_DOSISH_SYSTEM
323   setmode (fileno(fp), O_BINARY);
324 #endif
325   buffer = NULL;
326   buflen = 0;
327   do
328     {
329       bufsize += NCHUNK;
330       if (!buffer)
331         buffer = gcry_xmalloc (bufsize);
332       else
333         buffer = gcry_xrealloc (buffer, bufsize);
334
335       nread = fread (buffer + buflen, 1, NCHUNK, fp);
336       if (nread < NCHUNK && ferror (fp))
337         {
338           gcry_free (buffer);
339           return NULL;
340         }
341       buflen += nread;
342     }
343   while (nread == NCHUNK);
344 #undef NCHUNK
345   if (decode)
346     {
347       const char *s;
348       char *p;
349
350       for (s=buffer,p=buffer,nread=0; nread+1 < buflen; s += 2, nread +=2 )
351         {
352           if (!hexdigitp (s) || !hexdigitp (s+1))
353             {
354               gcry_free (buffer);
355               return NULL;  /* Invalid hex digits. */
356             }
357           *(unsigned char*)p++ = xtoi_2 (s);
358         }
359       if (nread != buflen)
360         {
361           gcry_free (buffer);
362           return NULL;  /* Odd number of hex digits. */
363         }
364       buflen = p - buffer;
365     }
366
367   *r_length = buflen;
368   return buffer;
369 }
370
371 /* Do in-place decoding of base-64 data of LENGTH in BUFFER.  Returns
372    the new length of the buffer.  Dies on error.  */
373 static size_t
374 base64_decode (char *buffer, size_t length)
375 {
376   static unsigned char const asctobin[128] =
377     {
378       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
379       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
380       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
381       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
382       0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0xff, 0xff,
383       0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
384       0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
385       0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
386       0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
387       0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
388       0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
389     };
390
391   int idx = 0;
392   unsigned char val = 0;
393   int c = 0;
394   char *d, *s;
395   int lfseen = 1;
396
397   /* Find BEGIN line.  */
398   for (s=buffer; length; length--, s++)
399     {
400       if (lfseen && *s == '-' && length > 11 && !memcmp (s, "-----BEGIN ", 11))
401         {
402           for (; length && *s != '\n'; length--, s++)
403             ;
404           break;
405         }
406       lfseen = (*s == '\n');
407     }
408
409   /* Decode until pad character or END line.  */
410   for (d=buffer; length; length--, s++)
411     {
412       if (lfseen && *s == '-' && length > 9 && !memcmp (s, "-----END ", 9))
413         break;
414       if ((lfseen = (*s == '\n')) || *s == ' ' || *s == '\r' || *s == '\t')
415         continue;
416       if (*s == '=')
417         {
418           /* Pad character: stop */
419           if (idx == 1)
420             *d++ = val;
421           break;
422         }
423
424       if ( (*s & 0x80) || (c = asctobin[*(unsigned char *)s]) == 0xff)
425         die ("invalid base64 character %02X at pos %d detected\n",
426              *(unsigned char*)s, (int)(s-buffer));
427
428       switch (idx)
429         {
430         case 0:
431           val = c << 2;
432           break;
433         case 1:
434           val |= (c>>4)&3;
435           *d++ = val;
436           val = (c<<4)&0xf0;
437           break;
438         case 2:
439           val |= (c>>2)&15;
440           *d++ = val;
441           val = (c<<6)&0xc0;
442           break;
443         case 3:
444           val |= c&0x3f;
445           *d++ = val;
446           break;
447         }
448       idx = (idx+1) % 4;
449     }
450
451   return d - buffer;
452 }
453
454
455 /* Parse the buffer at the address BUFFER which consists of the number
456    of octets as stored at BUFLEN.  Return the tag and the length part
457    from the TLV triplet.  Update BUFFER and BUFLEN on success.  Checks
458    that the encoded length does not exhaust the length of the provided
459    buffer. */
460 static int
461 parse_tag (unsigned char const **buffer, size_t *buflen, struct tag_info *ti)
462 {
463   int c;
464   unsigned long tag;
465   const unsigned char *buf = *buffer;
466   size_t length = *buflen;
467
468   ti->length = 0;
469   ti->ndef = 0;
470   ti->nhdr = 0;
471
472   /* Get the tag */
473   if (!length)
474     return -1; /* Premature EOF.  */
475   c = *buf++; length--;
476   ti->nhdr++;
477
478   ti->class = (c & 0xc0) >> 6;
479   ti->cons  = !!(c & 0x20);
480   tag       = (c & 0x1f);
481
482   if (tag == 0x1f)
483     {
484       tag = 0;
485       do
486         {
487           tag <<= 7;
488           if (!length)
489             return -1; /* Premature EOF.  */
490           c = *buf++; length--;
491           ti->nhdr++;
492           tag |= (c & 0x7f);
493         }
494       while ( (c & 0x80) );
495     }
496   ti->tag = tag;
497
498   /* Get the length */
499   if (!length)
500     return -1; /* Premature EOF. */
501   c = *buf++; length--;
502   ti->nhdr++;
503
504   if ( !(c & 0x80) )
505     ti->length = c;
506   else if (c == 0x80)
507     ti->ndef = 1;
508   else if (c == 0xff)
509     return -1; /* Forbidden length value.  */
510   else
511     {
512       unsigned long len = 0;
513       int count = c & 0x7f;
514
515       for (; count; count--)
516         {
517           len <<= 8;
518           if (!length)
519             return -1; /* Premature EOF.  */
520           c = *buf++; length--;
521           ti->nhdr++;
522           len |= (c & 0xff);
523         }
524       ti->length = len;
525     }
526
527   if (ti->class == UNIVERSAL && !ti->tag)
528     ti->length = 0;
529
530   if (ti->length > length)
531     return -1; /* Data larger than buffer.  */
532
533   *buffer = buf;
534   *buflen = length;
535   return 0;
536 }
537
538
539 /* Read the file FNAME assuming it is a PEM encoded private key file
540    and return an S-expression.  With SHOW set, the key parameters are
541    printed.  */
542 static gcry_sexp_t
543 read_private_key_file (const char *fname, int show)
544 {
545   gcry_error_t err;
546   FILE *fp;
547   char *buffer;
548   size_t buflen;
549   const unsigned char *der;
550   size_t derlen;
551   struct tag_info ti;
552   gcry_mpi_t keyparms[8];
553   int n_keyparms = 8;
554   int idx;
555   gcry_sexp_t s_key;
556
557   fp = fopen (fname, binary_input?"rb":"r");
558   if (!fp)
559     die ("can't open `%s': %s\n", fname, strerror (errno));
560   buffer = read_file (fp, 0, &buflen);
561   if (!buffer)
562     die ("error reading `%s'\n", fname);
563   fclose (fp);
564
565   buflen = base64_decode (buffer, buflen);
566
567   /* Parse the ASN.1 structure.  */
568   der = (const unsigned char*)buffer;
569   derlen = buflen;
570   if ( parse_tag (&der, &derlen, &ti)
571        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
572     goto bad_asn1;
573   if ( parse_tag (&der, &derlen, &ti)
574        || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
575     goto bad_asn1;
576   if (ti.length != 1 || *der)
577     goto bad_asn1;  /* The value of the first integer is no 0. */
578   der += ti.length; derlen -= ti.length;
579
580   for (idx=0; idx < n_keyparms; idx++)
581     {
582       if ( parse_tag (&der, &derlen, &ti)
583            || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
584         goto bad_asn1;
585       if (show)
586         {
587           char prefix[2];
588
589           prefix[0] = idx < 8? "nedpq12u"[idx] : '?';
590           prefix[1] = 0;
591           showhex (prefix, der, ti.length);
592         }
593       err = gcry_mpi_scan (keyparms+idx, GCRYMPI_FMT_USG, der, ti.length,NULL);
594       if (err)
595         die ("error scanning RSA parameter %d: %s\n", idx, gpg_strerror (err));
596       der += ti.length; derlen -= ti.length;
597     }
598   if (idx != n_keyparms)
599     die ("not enough RSA key parameters\n");
600
601   gcry_free (buffer);
602
603   /* Convert from OpenSSL parameter ordering to the OpenPGP order. */
604   /* First check that p < q; if not swap p and q and recompute u.  */
605   if (gcry_mpi_cmp (keyparms[3], keyparms[4]) > 0)
606     {
607       gcry_mpi_swap (keyparms[3], keyparms[4]);
608       gcry_mpi_invm (keyparms[7], keyparms[3], keyparms[4]);
609     }
610
611   /* Build the S-expression.  */
612   err = gcry_sexp_build (&s_key, NULL,
613                          "(private-key(rsa(n%m)(e%m)"
614                          /**/            "(d%m)(p%m)(q%m)(u%m)))",
615                          keyparms[0], keyparms[1], keyparms[2],
616                          keyparms[3], keyparms[4], keyparms[7] );
617   if (err)
618     die ("error building S-expression: %s\n", gpg_strerror (err));
619
620   for (idx=0; idx < n_keyparms; idx++)
621     gcry_mpi_release (keyparms[idx]);
622
623   return s_key;
624
625  bad_asn1:
626   die ("invalid ASN.1 structure in `%s'\n", fname);
627   return NULL; /*NOTREACHED*/
628 }
629
630
631 /* Read the file FNAME assuming it is a PEM encoded public key file
632    and return an S-expression.  With SHOW set, the key parameters are
633    printed.  */
634 static gcry_sexp_t
635 read_public_key_file (const char *fname, int show)
636 {
637   gcry_error_t err;
638   FILE *fp;
639   char *buffer;
640   size_t buflen;
641   const unsigned char *der;
642   size_t derlen;
643   struct tag_info ti;
644   gcry_mpi_t keyparms[2];
645   int n_keyparms = 2;
646   int idx;
647   gcry_sexp_t s_key;
648
649   fp = fopen (fname, binary_input?"rb":"r");
650   if (!fp)
651     die ("can't open `%s': %s\n", fname, strerror (errno));
652   buffer = read_file (fp, 0, &buflen);
653   if (!buffer)
654     die ("error reading `%s'\n", fname);
655   fclose (fp);
656
657   buflen = base64_decode (buffer, buflen);
658
659   /* Parse the ASN.1 structure.  */
660   der = (const unsigned char*)buffer;
661   derlen = buflen;
662   if ( parse_tag (&der, &derlen, &ti)
663        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
664     goto bad_asn1;
665   if ( parse_tag (&der, &derlen, &ti)
666        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
667     goto bad_asn1;
668   /* We skip the description of the key parameters and assume it is RSA.  */
669   der += ti.length; derlen -= ti.length;
670
671   if ( parse_tag (&der, &derlen, &ti)
672        || ti.tag != TAG_BIT_STRING || ti.class || ti.cons || ti.ndef)
673     goto bad_asn1;
674   if (ti.length < 1 || *der)
675     goto bad_asn1;  /* The number of unused bits needs to be 0. */
676   der += 1; derlen -= 1;
677
678   /* Parse the BIT string.  */
679   if ( parse_tag (&der, &derlen, &ti)
680        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
681     goto bad_asn1;
682
683   for (idx=0; idx < n_keyparms; idx++)
684     {
685       if ( parse_tag (&der, &derlen, &ti)
686            || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
687         goto bad_asn1;
688       if (show)
689         {
690           char prefix[2];
691
692           prefix[0] = idx < 2? "ne"[idx] : '?';
693           prefix[1] = 0;
694           showhex (prefix, der, ti.length);
695         }
696       err = gcry_mpi_scan (keyparms+idx, GCRYMPI_FMT_USG, der, ti.length,NULL);
697       if (err)
698         die ("error scanning RSA parameter %d: %s\n", idx, gpg_strerror (err));
699       der += ti.length; derlen -= ti.length;
700     }
701   if (idx != n_keyparms)
702     die ("not enough RSA key parameters\n");
703
704   gcry_free (buffer);
705
706   /* Build the S-expression.  */
707   err = gcry_sexp_build (&s_key, NULL,
708                          "(public-key(rsa(n%m)(e%m)))",
709                          keyparms[0], keyparms[1] );
710   if (err)
711     die ("error building S-expression: %s\n", gpg_strerror (err));
712
713   for (idx=0; idx < n_keyparms; idx++)
714     gcry_mpi_release (keyparms[idx]);
715
716   return s_key;
717
718  bad_asn1:
719   die ("invalid ASN.1 structure in `%s'\n", fname);
720   return NULL; /*NOTREACHED*/
721 }
722
723
724
725 /* Read the file FNAME assuming it is a binary signature result and
726    return an an S-expression suitable for gcry_pk_verify.  */
727 static gcry_sexp_t
728 read_sig_file (const char *fname)
729 {
730   gcry_error_t err;
731   FILE *fp;
732   char *buffer;
733   size_t buflen;
734   gcry_mpi_t tmpmpi;
735   gcry_sexp_t s_sig;
736
737   fp = fopen (fname, "rb");
738   if (!fp)
739     die ("can't open `%s': %s\n", fname, strerror (errno));
740   buffer = read_file (fp, 0, &buflen);
741   if (!buffer)
742     die ("error reading `%s'\n", fname);
743   fclose (fp);
744
745   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, buffer, buflen, NULL);
746   if (!err)
747     err = gcry_sexp_build (&s_sig, NULL,
748                            "(sig-val(rsa(s %m)))", tmpmpi);
749   if (err)
750     die ("error building S-expression: %s\n", gpg_strerror (err));
751   gcry_mpi_release (tmpmpi);
752   gcry_free (buffer);
753
754   return s_sig;
755 }
756
757
758 /* Read an S-expression from FNAME.  */
759 static gcry_sexp_t
760 read_sexp_from_file (const char *fname)
761 {
762   gcry_error_t err;
763   FILE *fp;
764   char *buffer;
765   size_t buflen;
766   gcry_sexp_t sexp;
767
768   fp = fopen (fname, "rb");
769   if (!fp)
770     die ("can't open `%s': %s\n", fname, strerror (errno));
771   buffer = read_file (fp, 0, &buflen);
772   if (!buffer)
773     die ("error reading `%s'\n", fname);
774   fclose (fp);
775   if (!buflen)
776     die ("error: file `%s' is empty\n", fname);
777
778   err = gcry_sexp_create (&sexp, buffer, buflen, 1, gcry_free);
779   if (err)
780     die ("error parsing `%s': %s\n", fname, gpg_strerror (err));
781
782   return sexp;
783 }
784
785
786 static void
787 print_buffer (const void *buffer, size_t length)
788 {
789   int writerr = 0;
790
791   if (base64_output)
792     {
793       static const unsigned char bintoasc[64+1] =
794         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
795         "abcdefghijklmnopqrstuvwxyz"
796         "0123456789+/";
797       const unsigned char *p;
798       unsigned char inbuf[4];
799       char outbuf[4];
800       int idx, quads;
801
802       idx = quads = 0;
803       for (p = buffer; length; p++, length--)
804         {
805           inbuf[idx++] = *p;
806           if (idx > 2)
807             {
808               outbuf[0] = bintoasc[(*inbuf>>2)&077];
809               outbuf[1] = bintoasc[(((*inbuf<<4)&060)
810                                     |((inbuf[1] >> 4)&017))&077];
811               outbuf[2] = bintoasc[(((inbuf[1]<<2)&074)
812                                     |((inbuf[2]>>6)&03))&077];
813               outbuf[3] = bintoasc[inbuf[2]&077];
814               if (fwrite (outbuf, 4, 1, stdout) != 1)
815                 writerr = 1;
816               idx = 0;
817               if (++quads >= (64/4))
818                 {
819                   if (fwrite ("\n", 1, 1, stdout) != 1)
820                     writerr = 1;
821                   quads = 0;
822                 }
823             }
824         }
825       if (idx)
826         {
827           outbuf[0] = bintoasc[(*inbuf>>2)&077];
828           if (idx == 1)
829             {
830               outbuf[1] = bintoasc[((*inbuf<<4)&060)&077];
831               outbuf[2] = outbuf[3] = '=';
832             }
833           else
834             {
835               outbuf[1] = bintoasc[(((*inbuf<<4)&060)
836                                     |((inbuf[1]>>4)&017))&077];
837               outbuf[2] = bintoasc[((inbuf[1]<<2)&074)&077];
838               outbuf[3] = '=';
839             }
840           if (fwrite (outbuf, 4, 1, stdout) != 1)
841             writerr = 1;
842           quads++;
843         }
844       if (quads && fwrite ("\n", 1, 1, stdout) != 1)
845         writerr = 1;
846     }
847   else if (binary_output)
848     {
849       if (fwrite (buffer, length, 1, stdout) != 1)
850         writerr++;
851     }
852   else
853     {
854       const unsigned char *p = buffer;
855
856       if (verbose > 1)
857         showhex ("sent line", buffer, length);
858       while (length-- && !ferror (stdout) )
859         printf ("%02X", *p++);
860       if (ferror (stdout))
861         writerr++;
862     }
863   if (!writerr && fflush (stdout) == EOF)
864     writerr++;
865   if (writerr)
866     {
867 #ifndef HAVE_W32_SYSTEM
868       if (loop_mode && errno == EPIPE)
869         loop_mode = 0;
870       else
871 #endif
872         die ("writing output failed: %s\n", strerror (errno));
873     }
874 }
875
876
877 /* Print an MPI on a line.  */
878 static void
879 print_mpi_line (gcry_mpi_t a, int no_lz)
880 {
881   unsigned char *buf, *p;
882   gcry_error_t err;
883   int writerr = 0;
884
885   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, a);
886   if (err)
887     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
888
889   p = buf;
890   if (no_lz && p[0] == '0' && p[1] == '0' && p[2])
891     p += 2;
892
893   printf ("%s\n", p);
894   if (ferror (stdout))
895     writerr++;
896   if (!writerr && fflush (stdout) == EOF)
897     writerr++;
898   if (writerr)
899     die ("writing output failed: %s\n", strerror (errno));
900   gcry_free (buf);
901 }
902
903
904 /* Print some data on hex format on a line.  */
905 static void
906 print_data_line (const void *data, size_t datalen)
907 {
908   const unsigned char *p = data;
909   int writerr = 0;
910
911   while (data && datalen-- && !ferror (stdout) )
912     printf ("%02X", *p++);
913   putchar ('\n');
914   if (ferror (stdout))
915     writerr++;
916   if (!writerr && fflush (stdout) == EOF)
917     writerr++;
918   if (writerr)
919     die ("writing output failed: %s\n", strerror (errno));
920 }
921
922 /* Print the S-expression A to the stream FP.  */
923 static void
924 print_sexp (gcry_sexp_t a, FILE *fp)
925 {
926   char *buf;
927   size_t size;
928
929   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
930   buf = gcry_xmalloc (size);
931   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
932   if (fwrite (buf, size, 1, fp) != 1)
933     die ("error writing to stream: %s\n", strerror (errno));
934   gcry_free (buf);
935 }
936
937
938
939
940 static gcry_error_t
941 init_external_rng_test (void **r_context,
942                     unsigned int flags,
943                     const void *key, size_t keylen,
944                     const void *seed, size_t seedlen,
945                     const void *dt, size_t dtlen)
946 {
947   return gcry_control (PRIV_CTL_INIT_EXTRNG_TEST,
948                        r_context, flags,
949                        key, keylen,
950                        seed, seedlen,
951                        dt, dtlen);
952 }
953
954 static gcry_error_t
955 run_external_rng_test (void *context, void *buffer, size_t buflen)
956 {
957   return gcry_control (PRIV_CTL_RUN_EXTRNG_TEST, context, buffer, buflen);
958 }
959
960 static void
961 deinit_external_rng_test (void *context)
962 {
963   gcry_control (PRIV_CTL_DEINIT_EXTRNG_TEST, context);
964 }
965
966
967 /* Given an OpenSSL cipher name NAME, return the Libgcrypt algirithm
968    identified and store the libgcrypt mode at R_MODE.  Returns 0 on
969    error.  */
970 static int
971 map_openssl_cipher_name (const char *name, int *r_mode)
972 {
973   static struct {
974     const char *name;
975     int algo;
976     int mode;
977   } table[] =
978     {
979       { "bf-cbc",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC },
980       { "bf",           GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC },
981       { "bf-cfb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CFB },
982       { "bf-ecb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_ECB },
983       { "bf-ofb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_OFB },
984
985       { "cast-cbc",     GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
986       { "cast",         GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
987       { "cast5-cbc",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
988       { "cast5-cfb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CFB },
989       { "cast5-ecb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_ECB },
990       { "cast5-ofb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_OFB },
991
992       { "des-cbc",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CBC },
993       { "des",          GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CBC },
994       { "des-cfb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CFB },
995       { "des-ofb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_OFB },
996       { "des-ecb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_ECB },
997
998       { "des-ede3-cbc", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC },
999       { "des-ede3",     GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_ECB },
1000       { "des3",         GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC },
1001       { "des-ede3-cfb", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CFB },
1002       { "des-ede3-ofb", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_OFB },
1003
1004       { "rc4",          GCRY_CIPHER_ARCFOUR, GCRY_CIPHER_MODE_STREAM },
1005
1006       { "aes-128-cbc",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC },
1007       { "aes-128",      GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC },
1008       { "aes-128-cfb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CFB },
1009       { "aes-128-ecb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB },
1010       { "aes-128-ofb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_OFB },
1011
1012       { "aes-192-cbc",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC },
1013       { "aes-192",      GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC },
1014       { "aes-192-cfb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB },
1015       { "aes-192-ecb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB },
1016       { "aes-192-ofb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB },
1017
1018       { "aes-256-cbc",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC },
1019       { "aes-256",      GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC },
1020       { "aes-256-cfb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB },
1021       { "aes-256-ecb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB },
1022       { "aes-256-ofb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB },
1023
1024       { NULL, 0 , 0 }
1025     };
1026   int idx;
1027
1028   for (idx=0; table[idx].name; idx++)
1029     if (!strcmp (name, table[idx].name))
1030       {
1031         *r_mode = table[idx].mode;
1032         return table[idx].algo;
1033       }
1034   *r_mode = 0;
1035   return 0;
1036 }
1037
1038
1039 \f
1040 /* Run an encrypt or decryption operations.  If DATA is NULL the
1041    function reads its input in chunks of size DATALEN from fp and
1042    processes it and writes it out until EOF.  */
1043 static void
1044 run_encrypt_decrypt (int encrypt_mode,
1045                      int cipher_algo, int cipher_mode,
1046                      const void *iv_buffer, size_t iv_buflen,
1047                      const void *key_buffer, size_t key_buflen,
1048                      const void *data, size_t datalen, FILE *fp)
1049 {
1050   gpg_error_t err;
1051   gcry_cipher_hd_t hd;
1052   void *outbuf;
1053   size_t outbuflen;
1054   void *inbuf;
1055   size_t inbuflen;
1056   size_t blocklen;
1057
1058   err = gcry_cipher_open (&hd, cipher_algo, cipher_mode, 0);
1059   if (err)
1060     die ("gcry_cipher_open failed for algo %d, mode %d: %s\n",
1061          cipher_algo, cipher_mode, gpg_strerror (err));
1062
1063   blocklen = gcry_cipher_get_algo_blklen (cipher_algo);
1064   assert (blocklen);
1065
1066   gcry_cipher_ctl (hd, PRIV_CIPHERCTL_DISABLE_WEAK_KEY, NULL, 0);
1067
1068   err = gcry_cipher_setkey (hd, key_buffer, key_buflen);
1069   if (err)
1070     die ("gcry_cipher_setkey failed with keylen %u: %s\n",
1071          (unsigned int)key_buflen, gpg_strerror (err));
1072
1073   if (iv_buffer)
1074     {
1075       err = gcry_cipher_setiv (hd, iv_buffer, iv_buflen);
1076       if (err)
1077         die ("gcry_cipher_setiv failed with ivlen %u: %s\n",
1078              (unsigned int)iv_buflen, gpg_strerror (err));
1079     }
1080
1081   inbuf = data? NULL : gcry_xmalloc (datalen);
1082   outbuflen = datalen;
1083   outbuf = gcry_xmalloc (outbuflen < blocklen? blocklen:outbuflen);
1084
1085   do
1086     {
1087       if (inbuf)
1088         {
1089           int nread = fread (inbuf, 1, datalen, fp);
1090           if (nread < (int)datalen && ferror (fp))
1091             die ("error reading input\n");
1092           data = inbuf;
1093           inbuflen = nread;
1094         }
1095       else
1096         inbuflen = datalen;
1097
1098       if (encrypt_mode)
1099         err = gcry_cipher_encrypt (hd, outbuf, outbuflen, data, inbuflen);
1100       else
1101         err = gcry_cipher_decrypt (hd, outbuf, outbuflen, data, inbuflen);
1102       if (err)
1103         die ("gcry_cipher_%scrypt failed: %s\n",
1104              encrypt_mode? "en":"de", gpg_strerror (err));
1105
1106       print_buffer (outbuf, outbuflen);
1107     }
1108   while (inbuf);
1109
1110   gcry_cipher_close (hd);
1111   gcry_free (outbuf);
1112   gcry_free (inbuf);
1113 }
1114
1115
1116 static void
1117 get_current_iv (gcry_cipher_hd_t hd, void *buffer, size_t buflen)
1118 {
1119   unsigned char tmp[17];
1120
1121   if (gcry_cipher_ctl (hd, PRIV_CIPHERCTL_GET_INPUT_VECTOR, tmp, sizeof tmp))
1122     die ("error getting current input vector\n");
1123   if (buflen > *tmp)
1124     die ("buffer too short to store the current input vector\n");
1125   memcpy (buffer, tmp+1, *tmp);
1126 }
1127
1128 /* Run the inner loop of the CAVS monte carlo test.  */
1129 static void
1130 run_cipher_mct_loop (int encrypt_mode, int cipher_algo, int cipher_mode,
1131                      const void *iv_buffer, size_t iv_buflen,
1132                      const void *key_buffer, size_t key_buflen,
1133                      const void *data, size_t datalen, int iterations)
1134 {
1135   gpg_error_t err;
1136   gcry_cipher_hd_t hd;
1137   size_t blocklen;
1138   int count;
1139   char input[16];
1140   char output[16];
1141   char last_output[16];
1142   char last_last_output[16];
1143   char last_iv[16];
1144
1145
1146   err = gcry_cipher_open (&hd, cipher_algo, cipher_mode, 0);
1147   if (err)
1148     die ("gcry_cipher_open failed for algo %d, mode %d: %s\n",
1149          cipher_algo, cipher_mode, gpg_strerror (err));
1150
1151   blocklen = gcry_cipher_get_algo_blklen (cipher_algo);
1152   if (!blocklen || blocklen > sizeof output)
1153     die ("invalid block length %d\n", blocklen);
1154
1155
1156   gcry_cipher_ctl (hd, PRIV_CIPHERCTL_DISABLE_WEAK_KEY, NULL, 0);
1157
1158   err = gcry_cipher_setkey (hd, key_buffer, key_buflen);
1159   if (err)
1160     die ("gcry_cipher_setkey failed with keylen %u: %s\n",
1161          (unsigned int)key_buflen, gpg_strerror (err));
1162
1163   if (iv_buffer)
1164     {
1165       err = gcry_cipher_setiv (hd, iv_buffer, iv_buflen);
1166       if (err)
1167         die ("gcry_cipher_setiv failed with ivlen %u: %s\n",
1168              (unsigned int)iv_buflen, gpg_strerror (err));
1169     }
1170
1171   if (datalen != blocklen)
1172     die ("length of input (%u) does not match block length (%u)\n",
1173          (unsigned int)datalen, (unsigned int)blocklen);
1174   memcpy (input, data, datalen);
1175   memset (output, 0, sizeof output);
1176   for (count=0; count < iterations; count++)
1177     {
1178       memcpy (last_last_output, last_output, sizeof last_output);
1179       memcpy (last_output, output, sizeof output);
1180
1181       get_current_iv (hd, last_iv, blocklen);
1182
1183       if (encrypt_mode)
1184         err = gcry_cipher_encrypt (hd, output, blocklen, input, blocklen);
1185       else
1186         err = gcry_cipher_decrypt (hd, output, blocklen, input, blocklen);
1187       if (err)
1188         die ("gcry_cipher_%scrypt failed: %s\n",
1189              encrypt_mode? "en":"de", gpg_strerror (err));
1190
1191
1192       if (encrypt_mode && (cipher_mode == GCRY_CIPHER_MODE_CFB
1193                            || cipher_mode == GCRY_CIPHER_MODE_CBC))
1194         memcpy (input, last_iv, blocklen);
1195       else if (cipher_mode == GCRY_CIPHER_MODE_OFB)
1196         memcpy (input, last_iv, blocklen);
1197       else if (!encrypt_mode && cipher_mode == GCRY_CIPHER_MODE_CFB)
1198         {
1199           /* Reconstruct the output vector.  */
1200           int i;
1201           for (i=0; i < blocklen; i++)
1202             input[i] ^= output[i];
1203         }
1204       else
1205         memcpy (input, output, blocklen);
1206     }
1207
1208   print_buffer (output, blocklen);
1209   putchar ('\n');
1210   print_buffer (last_output, blocklen);
1211   putchar ('\n');
1212   print_buffer (last_last_output, blocklen);
1213   putchar ('\n');
1214   get_current_iv (hd, last_iv, blocklen);
1215   print_buffer (last_iv, blocklen); /* Last output vector.  */
1216   putchar ('\n');
1217   print_buffer (input, blocklen);   /* Next input text. */
1218   putchar ('\n');
1219   if (verbose > 1)
1220     showhex ("sent line", "", 0);
1221   putchar ('\n');
1222   fflush (stdout);
1223
1224   gcry_cipher_close (hd);
1225 }
1226
1227
1228 \f
1229 /* Run a digest operation.  */
1230 static void
1231 run_digest (int digest_algo,  const void *data, size_t datalen)
1232 {
1233   gpg_error_t err;
1234   gcry_md_hd_t hd;
1235   const unsigned char *digest;
1236   unsigned int digestlen;
1237
1238   err = gcry_md_open (&hd, digest_algo, 0);
1239   if (err)
1240     die ("gcry_md_open failed for algo %d: %s\n",
1241          digest_algo,  gpg_strerror (err));
1242
1243   gcry_md_write (hd, data, datalen);
1244   digest = gcry_md_read (hd, digest_algo);
1245   digestlen = gcry_md_get_algo_dlen (digest_algo);
1246   print_buffer (digest, digestlen);
1247   gcry_md_close (hd);
1248 }
1249
1250 \f
1251 /* Run a HMAC operation.  */
1252 static void
1253 run_hmac (int digest_algo, const void *key, size_t keylen,
1254           const void *data, size_t datalen)
1255 {
1256   gpg_error_t err;
1257   gcry_md_hd_t hd;
1258   const unsigned char *digest;
1259   unsigned int digestlen;
1260
1261   err = gcry_md_open (&hd, digest_algo, GCRY_MD_FLAG_HMAC);
1262   if (err)
1263     die ("gcry_md_open failed for HMAC algo %d: %s\n",
1264          digest_algo,  gpg_strerror (err));
1265
1266   gcry_md_setkey (hd, key, keylen);
1267   if (err)
1268     die ("gcry_md_setkey failed for HMAC algo %d: %s\n",
1269          digest_algo,  gpg_strerror (err));
1270
1271   gcry_md_write (hd, data, datalen);
1272   digest = gcry_md_read (hd, digest_algo);
1273   digestlen = gcry_md_get_algo_dlen (digest_algo);
1274   print_buffer (digest, digestlen);
1275   gcry_md_close (hd);
1276 }
1277
1278
1279 \f
1280 /* Derive an RSA key using the S-expression in (DATA,DATALEN).  This
1281    S-expression is used directly as input to gcry_pk_genkey.  The
1282    result is printed to stdout with one parameter per line in hex
1283    format and in this order: p, q, n, d.  */
1284 static void
1285 run_rsa_derive (const void *data, size_t datalen)
1286 {
1287   gpg_error_t err;
1288   gcry_sexp_t s_keyspec, s_key, s_top, l1;
1289   gcry_mpi_t mpi;
1290   const char *parmlist;
1291   int idx;
1292
1293   if (!datalen)
1294     err = gpg_error (GPG_ERR_NO_DATA);
1295   else
1296     err = gcry_sexp_new (&s_keyspec, data, datalen, 1);
1297   if (err)
1298     die ("gcry_sexp_new failed for RSA key derive: %s\n",
1299          gpg_strerror (err));
1300
1301   err = gcry_pk_genkey (&s_key, s_keyspec);
1302   if (err)
1303     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
1304
1305   gcry_sexp_release (s_keyspec);
1306
1307   /* P and Q might have been swapped but we need to to return them in
1308      the proper order.  Build the parameter list accordingly.  */
1309   parmlist = "pqnd";
1310   s_top = gcry_sexp_find_token (s_key, "misc-key-info", 0);
1311   if (s_top)
1312     {
1313       l1 = gcry_sexp_find_token (s_top, "p-q-swapped", 0);
1314       if (l1)
1315         parmlist = "qpnd";
1316       gcry_sexp_release (l1);
1317       gcry_sexp_release (s_top);
1318     }
1319
1320   /* Parse and print the parameters.  */
1321   l1 = gcry_sexp_find_token (s_key, "private-key", 0);
1322   s_top = gcry_sexp_find_token (l1, "rsa", 0);
1323   gcry_sexp_release (l1);
1324   if (!s_top)
1325     die ("private-key part not found in result\n");
1326
1327   for (idx=0; parmlist[idx]; idx++)
1328     {
1329       l1 = gcry_sexp_find_token (s_top, parmlist+idx, 1);
1330       mpi = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1331       gcry_sexp_release (l1);
1332       if (!mpi)
1333         die ("parameter %c missing in private-key\n", parmlist[idx]);
1334       print_mpi_line (mpi, 1);
1335       gcry_mpi_release (mpi);
1336     }
1337
1338   gcry_sexp_release (s_top);
1339   gcry_sexp_release (s_key);
1340 }
1341
1342
1343 \f
1344 static size_t
1345 compute_tag_length (size_t n)
1346 {
1347   int needed = 0;
1348
1349   if (n < 128)
1350     needed += 2; /* Tag and one length byte.  */
1351   else if (n < 256)
1352     needed += 3; /* Tag, number of length bytes, 1 length byte.  */
1353   else if (n < 65536)
1354     needed += 4; /* Tag, number of length bytes, 2 length bytes.  */
1355   else
1356     die ("DER object too long to encode\n");
1357
1358   return needed;
1359 }
1360
1361 static unsigned char *
1362 store_tag_length (unsigned char *p, int tag, size_t n)
1363 {
1364   if (tag == TAG_SEQUENCE)
1365     tag |= 0x20; /* constructed */
1366
1367   *p++ = tag;
1368   if (n < 128)
1369     *p++ = n;
1370   else if (n < 256)
1371     {
1372       *p++ = 0x81;
1373       *p++ = n;
1374     }
1375   else if (n < 65536)
1376     {
1377       *p++ = 0x82;
1378       *p++ = n >> 8;
1379       *p++ = n;
1380     }
1381
1382   return p;
1383 }
1384
1385
1386 /* Generate an RSA key of size KEYSIZE using the public exponent
1387    PUBEXP and print it to stdout in the OpenSSL format.  The format
1388    is:
1389
1390        SEQUENCE {
1391          INTEGER (0)  -- Unknown constant.
1392          INTEGER      -- n
1393          INTEGER      -- e
1394          INTEGER      -- d
1395          INTEGER      -- p
1396          INTEGER      -- q      (with p < q)
1397          INTEGER      -- dmp1 = d mod (p-1)
1398          INTEGER      -- dmq1 = d mod (q-1)
1399          INTEGER      -- u    = p^{-1} mod q
1400        }
1401
1402 */
1403 static void
1404 run_rsa_gen (int keysize, int pubexp)
1405 {
1406   gpg_error_t err;
1407   gcry_sexp_t keyspec, key, l1;
1408   const char keyelems[] = "nedpq..u";
1409   gcry_mpi_t keyparms[8];
1410   size_t     keyparmslen[8];
1411   int idx;
1412   size_t derlen, needed, n;
1413   unsigned char *derbuf, *der;
1414
1415   err = gcry_sexp_build (&keyspec, NULL,
1416                          "(genkey (rsa (nbits %d)(rsa-use-e %d)))",
1417                          keysize, pubexp);
1418   if (err)
1419     die ("gcry_sexp_build failed for RSA key generation: %s\n",
1420          gpg_strerror (err));
1421
1422   err = gcry_pk_genkey (&key, keyspec);
1423   if (err)
1424     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
1425
1426   gcry_sexp_release (keyspec);
1427
1428   l1 = gcry_sexp_find_token (key, "private-key", 0);
1429   if (!l1)
1430     die ("private key not found in genkey result\n");
1431   gcry_sexp_release (key);
1432   key = l1;
1433
1434   l1 = gcry_sexp_find_token (key, "rsa", 0);
1435   if (!l1)
1436     die ("returned private key not formed as expected\n");
1437   gcry_sexp_release (key);
1438   key = l1;
1439
1440   /* Extract the parameters from the S-expression and store them in a
1441      well defined order in KEYPARMS.  */
1442   for (idx=0; idx < DIM(keyparms); idx++)
1443     {
1444       if (keyelems[idx] == '.')
1445         {
1446           keyparms[idx] = gcry_mpi_new (0);
1447           continue;
1448         }
1449       l1 = gcry_sexp_find_token (key, keyelems+idx, 1);
1450       if (!l1)
1451         die ("no %c parameter in returned private key\n", keyelems[idx]);
1452       keyparms[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1453       if (!keyparms[idx])
1454         die ("no value for %c parameter in returned private key\n",
1455              keyelems[idx]);
1456       gcry_sexp_release (l1);
1457     }
1458
1459   gcry_sexp_release (key);
1460
1461   /* Check that p < q; if not swap p and q and recompute u.  */
1462   if (gcry_mpi_cmp (keyparms[3], keyparms[4]) > 0)
1463     {
1464       gcry_mpi_swap (keyparms[3], keyparms[4]);
1465       gcry_mpi_invm (keyparms[7], keyparms[3], keyparms[4]);
1466     }
1467
1468   /* Compute the additional parameters.  */
1469   gcry_mpi_sub_ui (keyparms[5], keyparms[3], 1);
1470   gcry_mpi_mod (keyparms[5], keyparms[2], keyparms[5]);
1471   gcry_mpi_sub_ui (keyparms[6], keyparms[4], 1);
1472   gcry_mpi_mod (keyparms[6], keyparms[2], keyparms[6]);
1473
1474   /* Compute the length of the DER encoding.  */
1475   needed = compute_tag_length (1) + 1;
1476   for (idx=0; idx < DIM(keyparms); idx++)
1477     {
1478       err = gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &n, keyparms[idx]);
1479       if (err)
1480         die ("error formatting parameter: %s\n", gpg_strerror (err));
1481       keyparmslen[idx] = n;
1482       needed += compute_tag_length (n) + n;
1483     }
1484
1485   /* Store the key parameters. */
1486   derlen = compute_tag_length (needed) + needed;
1487   der = derbuf = gcry_xmalloc (derlen);
1488
1489   der = store_tag_length (der, TAG_SEQUENCE, needed);
1490   der = store_tag_length (der, TAG_INTEGER, 1);
1491   *der++ = 0;
1492   for (idx=0; idx < DIM(keyparms); idx++)
1493     {
1494       der = store_tag_length (der, TAG_INTEGER, keyparmslen[idx]);
1495       err = gcry_mpi_print (GCRYMPI_FMT_STD, der,
1496                            keyparmslen[idx], NULL, keyparms[idx]);
1497       if (err)
1498         die ("error formatting parameter: %s\n", gpg_strerror (err));
1499       der += keyparmslen[idx];
1500     }
1501
1502   /* Print the stuff.  */
1503   for (idx=0; idx < DIM(keyparms); idx++)
1504     gcry_mpi_release (keyparms[idx]);
1505
1506   assert (der - derbuf == derlen);
1507
1508   if (base64_output)
1509     puts ("-----BEGIN RSA PRIVATE KEY-----");
1510   print_buffer (derbuf, derlen);
1511   if (base64_output)
1512     puts ("-----END RSA PRIVATE KEY-----");
1513
1514   gcry_free (derbuf);
1515 }
1516
1517
1518 \f
1519 /* Sign DATA of length DATALEN using the key taken from the PEM
1520    encoded KEYFILE and the hash algorithm HASHALGO.  */
1521 static void
1522 run_rsa_sign (const void *data, size_t datalen,
1523               int hashalgo, int pkcs1, const char *keyfile)
1524
1525 {
1526   gpg_error_t err;
1527   gcry_sexp_t s_data, s_key, s_sig, s_tmp;
1528   gcry_mpi_t sig_mpi = NULL;
1529   unsigned char *outbuf;
1530   size_t outlen;
1531
1532 /*   showhex ("D", data, datalen); */
1533   if (pkcs1)
1534     {
1535       unsigned char hash[64];
1536       unsigned int hashsize;
1537
1538       hashsize = gcry_md_get_algo_dlen (hashalgo);
1539       if (!hashsize || hashsize > sizeof hash)
1540         die ("digest too long for buffer or unknown hash algorithm\n");
1541       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
1542       err = gcry_sexp_build (&s_data, NULL,
1543                              "(data (flags pkcs1)(hash %s %b))",
1544                              gcry_md_algo_name (hashalgo),
1545                              (int)hashsize, hash);
1546     }
1547   else
1548     {
1549       gcry_mpi_t tmp;
1550
1551       err = gcry_mpi_scan (&tmp, GCRYMPI_FMT_USG, data, datalen,NULL);
1552       if (!err)
1553         {
1554           err = gcry_sexp_build (&s_data, NULL,
1555                                  "(data (flags raw)(value %m))", tmp);
1556           gcry_mpi_release (tmp);
1557         }
1558     }
1559   if (err)
1560     die ("gcry_sexp_build failed for RSA data input: %s\n",
1561          gpg_strerror (err));
1562
1563   s_key = read_private_key_file (keyfile, 0);
1564
1565   err = gcry_pk_sign (&s_sig, s_data, s_key);
1566   if (err)
1567     {
1568       gcry_sexp_release (read_private_key_file (keyfile, 1));
1569       die ("gcry_pk_signed failed (datalen=%d,keyfile=%s): %s\n",
1570            (int)datalen, keyfile, gpg_strerror (err));
1571     }
1572   gcry_sexp_release (s_key);
1573   gcry_sexp_release (s_data);
1574
1575   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
1576   if (s_tmp)
1577     {
1578       gcry_sexp_release (s_sig);
1579       s_sig = s_tmp;
1580       s_tmp = gcry_sexp_find_token (s_sig, "rsa", 0);
1581       if (s_tmp)
1582         {
1583           gcry_sexp_release (s_sig);
1584           s_sig = s_tmp;
1585           s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
1586           if (s_tmp)
1587             {
1588               gcry_sexp_release (s_sig);
1589               s_sig = s_tmp;
1590               sig_mpi = gcry_sexp_nth_mpi (s_sig, 1, GCRYMPI_FMT_USG);
1591             }
1592         }
1593     }
1594   gcry_sexp_release (s_sig);
1595
1596   if (!sig_mpi)
1597     die ("no value in returned S-expression\n");
1598   err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &outbuf, &outlen, sig_mpi);
1599   if (err)
1600     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
1601   gcry_mpi_release (sig_mpi);
1602
1603   print_buffer (outbuf, outlen);
1604   gcry_free (outbuf);
1605 }
1606
1607
1608 \f
1609 /* Verify DATA of length DATALEN using the public key taken from the
1610    PEM encoded KEYFILE and the hash algorithm HASHALGO against the
1611    binary signature in SIGFILE.  */
1612 static void
1613 run_rsa_verify (const void *data, size_t datalen, int hashalgo, int pkcs1,
1614                 const char *keyfile, const char *sigfile)
1615
1616 {
1617   gpg_error_t err;
1618   gcry_sexp_t s_data, s_key, s_sig;
1619
1620   if (pkcs1)
1621     {
1622       unsigned char hash[64];
1623       unsigned int hashsize;
1624
1625       hashsize = gcry_md_get_algo_dlen (hashalgo);
1626       if (!hashsize || hashsize > sizeof hash)
1627         die ("digest too long for buffer or unknown hash algorithm\n");
1628       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
1629       err = gcry_sexp_build (&s_data, NULL,
1630                              "(data (flags pkcs1)(hash %s %b))",
1631                              gcry_md_algo_name (hashalgo),
1632                              (int)hashsize, hash);
1633     }
1634   else
1635     {
1636       gcry_mpi_t tmp;
1637
1638       err = gcry_mpi_scan (&tmp, GCRYMPI_FMT_USG, data, datalen,NULL);
1639       if (!err)
1640         {
1641           err = gcry_sexp_build (&s_data, NULL,
1642                                  "(data (flags raw)(value %m))", tmp);
1643           gcry_mpi_release (tmp);
1644         }
1645     }
1646   if (err)
1647     die ("gcry_sexp_build failed for RSA data input: %s\n",
1648          gpg_strerror (err));
1649
1650   s_key = read_public_key_file (keyfile, 0);
1651
1652   s_sig = read_sig_file (sigfile);
1653
1654   err = gcry_pk_verify (s_sig, s_data, s_key);
1655   if (!err)
1656     puts ("GOOD signature");
1657   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
1658     puts ("BAD signature");
1659   else
1660     printf ("ERROR (%s)\n", gpg_strerror (err));
1661
1662   gcry_sexp_release (s_sig);
1663   gcry_sexp_release (s_key);
1664   gcry_sexp_release (s_data);
1665 }
1666
1667
1668 \f
1669 /* Generate a DSA key of size KEYSIZE and return the complete
1670    S-expression.  */
1671 static gcry_sexp_t
1672 dsa_gen (int keysize)
1673 {
1674   gpg_error_t err;
1675   gcry_sexp_t keyspec, key;
1676
1677   err = gcry_sexp_build (&keyspec, NULL,
1678                          "(genkey (dsa (nbits %d)(use-fips186-2)))",
1679                          keysize);
1680   if (err)
1681     die ("gcry_sexp_build failed for DSA key generation: %s\n",
1682          gpg_strerror (err));
1683
1684   err = gcry_pk_genkey (&key, keyspec);
1685   if (err)
1686     die ("gcry_pk_genkey failed for DSA: %s\n", gpg_strerror (err));
1687
1688   gcry_sexp_release (keyspec);
1689
1690   return key;
1691 }
1692
1693
1694 /* Generate a DSA key of size KEYSIZE and return the complete
1695    S-expression.  */
1696 static gcry_sexp_t
1697 dsa_gen_with_seed (int keysize, const void *seed, size_t seedlen)
1698 {
1699   gpg_error_t err;
1700   gcry_sexp_t keyspec, key;
1701
1702   err = gcry_sexp_build (&keyspec, NULL,
1703                          "(genkey"
1704                          "  (dsa"
1705                          "    (nbits %d)"
1706                          "    (use-fips186-2)"
1707                          "    (derive-parms"
1708                          "      (seed %b))))",
1709                          keysize, (int)seedlen, seed);
1710   if (err)
1711     die ("gcry_sexp_build failed for DSA key generation: %s\n",
1712          gpg_strerror (err));
1713
1714   err = gcry_pk_genkey (&key, keyspec);
1715   if (err)
1716     die ("gcry_pk_genkey failed for DSA: %s\n", gpg_strerror (err));
1717
1718   gcry_sexp_release (keyspec);
1719
1720   return key;
1721 }
1722
1723
1724 /* Print the domain parameter as well as the derive information.  KEY
1725    is the complete key as returned by dsa_gen.  We print to stdout
1726    with one parameter per line in hex format using this order: p, q,
1727    g, seed, counter, h. */
1728 static void
1729 print_dsa_domain_parameters (gcry_sexp_t key)
1730 {
1731   gcry_sexp_t l1, l2;
1732   gcry_mpi_t mpi;
1733   int idx;
1734   const void *data;
1735   size_t datalen;
1736   char *string;
1737
1738   l1 = gcry_sexp_find_token (key, "public-key", 0);
1739   if (!l1)
1740     die ("public key not found in genkey result\n");
1741
1742   l2 = gcry_sexp_find_token (l1, "dsa", 0);
1743   if (!l2)
1744     die ("returned public key not formed as expected\n");
1745   gcry_sexp_release (l1);
1746   l1 = l2;
1747
1748   /* Extract the parameters from the S-expression and print them to stdout.  */
1749   for (idx=0; "pqg"[idx]; idx++)
1750     {
1751       l2 = gcry_sexp_find_token (l1, "pqg"+idx, 1);
1752       if (!l2)
1753         die ("no %c parameter in returned public key\n", "pqg"[idx]);
1754       mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1755       if (!mpi)
1756         die ("no value for %c parameter in returned public key\n","pqg"[idx]);
1757       gcry_sexp_release (l2);
1758       if (standalone_mode)
1759         printf ("%c = ", "PQG"[idx]);
1760       print_mpi_line (mpi, 1);
1761       gcry_mpi_release (mpi);
1762     }
1763   gcry_sexp_release (l1);
1764
1765   /* Extract the seed values.  */
1766   l1 = gcry_sexp_find_token (key, "misc-key-info", 0);
1767   if (!l1)
1768     die ("misc-key-info not found in genkey result\n");
1769
1770   l2 = gcry_sexp_find_token (l1, "seed-values", 0);
1771   if (!l2)
1772     die ("no seed-values in returned key\n");
1773   gcry_sexp_release (l1);
1774   l1 = l2;
1775
1776   l2 = gcry_sexp_find_token (l1, "seed", 0);
1777   if (!l2)
1778     die ("no seed value in returned key\n");
1779   data = gcry_sexp_nth_data (l2, 1, &datalen);
1780   if (!data)
1781     die ("no seed value in returned key\n");
1782   if (standalone_mode)
1783     printf ("Seed = ");
1784   print_data_line (data, datalen);
1785   gcry_sexp_release (l2);
1786
1787   l2 = gcry_sexp_find_token (l1, "counter", 0);
1788   if (!l2)
1789     die ("no counter value in returned key\n");
1790   string = gcry_sexp_nth_string (l2, 1);
1791   if (!string)
1792     die ("no counter value in returned key\n");
1793   if (standalone_mode)
1794     printf ("c = %ld\n", strtoul (string, NULL, 10));
1795   else
1796     printf ("%lX\n", strtoul (string, NULL, 10));
1797   gcry_free (string);
1798   gcry_sexp_release (l2);
1799
1800   l2 = gcry_sexp_find_token (l1, "h", 0);
1801   if (!l2)
1802     die ("no n value in returned key\n");
1803   mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1804   if (!mpi)
1805     die ("no h value in returned key\n");
1806   if (standalone_mode)
1807     printf ("H = ");
1808   print_mpi_line (mpi, 1);
1809   gcry_mpi_release (mpi);
1810   gcry_sexp_release (l2);
1811
1812   gcry_sexp_release (l1);
1813 }
1814
1815
1816 /* Generate DSA domain parameters for a modulus size of KEYSIZE.  The
1817    result is printed to stdout with one parameter per line in hex
1818    format and in this order: p, q, g, seed, counter, h.  If SEED is
1819    not NULL this seed value will be used for the generation.  */
1820 static void
1821 run_dsa_pqg_gen (int keysize, const void *seed, size_t seedlen)
1822 {
1823   gcry_sexp_t key;
1824
1825   if (seed)
1826     key = dsa_gen_with_seed (keysize, seed, seedlen);
1827   else
1828     key = dsa_gen (keysize);
1829   print_dsa_domain_parameters (key);
1830   gcry_sexp_release (key);
1831 }
1832
1833
1834 /* Generate a DSA key of size of KEYSIZE and write the private key to
1835    FILENAME.  Also write the parameters to stdout in the same way as
1836    run_dsa_pqg_gen.  */
1837 static void
1838 run_dsa_gen (int keysize, const char *filename)
1839 {
1840   gcry_sexp_t key, private_key;
1841   FILE *fp;
1842
1843   key = dsa_gen (keysize);
1844   private_key = gcry_sexp_find_token (key, "private-key", 0);
1845   if (!private_key)
1846     die ("private key not found in genkey result\n");
1847   print_dsa_domain_parameters (key);
1848
1849   fp = fopen (filename, "wb");
1850   if (!fp)
1851     die ("can't create `%s': %s\n", filename, strerror (errno));
1852   print_sexp (private_key, fp);
1853   fclose (fp);
1854
1855   gcry_sexp_release (private_key);
1856   gcry_sexp_release (key);
1857 }
1858
1859
1860 \f
1861 /* Sign DATA of length DATALEN using the key taken from the S-expression
1862    encoded KEYFILE. */
1863 static void
1864 run_dsa_sign (const void *data, size_t datalen, const char *keyfile)
1865
1866 {
1867   gpg_error_t err;
1868   gcry_sexp_t s_data, s_key, s_sig, s_tmp, s_tmp2;
1869   char hash[20];
1870   gcry_mpi_t tmpmpi;
1871
1872   gcry_md_hash_buffer (GCRY_MD_SHA1, hash, data, datalen);
1873   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash, 20, NULL);
1874   if (!err)
1875     {
1876       err = gcry_sexp_build (&s_data, NULL,
1877                              "(data (flags raw)(value %m))", tmpmpi);
1878       gcry_mpi_release (tmpmpi);
1879     }
1880   if (err)
1881     die ("gcry_sexp_build failed for DSA data input: %s\n",
1882          gpg_strerror (err));
1883
1884   s_key = read_sexp_from_file (keyfile);
1885
1886   err = gcry_pk_sign (&s_sig, s_data, s_key);
1887   if (err)
1888     {
1889       gcry_sexp_release (read_private_key_file (keyfile, 1));
1890       die ("gcry_pk_signed failed (datalen=%d,keyfile=%s): %s\n",
1891            (int)datalen, keyfile, gpg_strerror (err));
1892     }
1893   gcry_sexp_release (s_data);
1894
1895   /* We need to return the Y parameter first.  */
1896   s_tmp = gcry_sexp_find_token (s_key, "private-key", 0);
1897   if (!s_tmp)
1898     die ("private key part not found in provided key\n");
1899
1900   s_tmp2 = gcry_sexp_find_token (s_tmp, "dsa", 0);
1901   if (!s_tmp2)
1902     die ("private key part is not a DSA key\n");
1903   gcry_sexp_release (s_tmp);
1904
1905   s_tmp = gcry_sexp_find_token (s_tmp2, "y", 0);
1906   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
1907   if (!tmpmpi)
1908     die ("no y parameter in DSA key\n");
1909   print_mpi_line (tmpmpi, 1);
1910   gcry_mpi_release (tmpmpi);
1911   gcry_sexp_release (s_tmp);
1912
1913   gcry_sexp_release (s_key);
1914
1915
1916   /* Now return the actual signature.  */
1917   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
1918   if (!s_tmp)
1919     die ("no sig-val element in returned S-expression\n");
1920
1921   gcry_sexp_release (s_sig);
1922   s_sig = s_tmp;
1923   s_tmp = gcry_sexp_find_token (s_sig, "dsa", 0);
1924   if (!s_tmp)
1925     die ("no dsa element in returned S-expression\n");
1926
1927   gcry_sexp_release (s_sig);
1928   s_sig = s_tmp;
1929
1930   s_tmp = gcry_sexp_find_token (s_sig, "r", 0);
1931   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
1932   if (!tmpmpi)
1933     die ("no r parameter in returned S-expression\n");
1934   print_mpi_line (tmpmpi, 1);
1935   gcry_mpi_release (tmpmpi);
1936   gcry_sexp_release (s_tmp);
1937
1938   s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
1939   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
1940   if (!tmpmpi)
1941     die ("no s parameter in returned S-expression\n");
1942   print_mpi_line (tmpmpi, 1);
1943   gcry_mpi_release (tmpmpi);
1944   gcry_sexp_release (s_tmp);
1945
1946   gcry_sexp_release (s_sig);
1947 }
1948
1949
1950 \f
1951 /* Verify DATA of length DATALEN using the public key taken from the
1952    S-expression in KEYFILE against the S-expression formatted
1953    signature in SIGFILE.  */
1954 static void
1955 run_dsa_verify (const void *data, size_t datalen,
1956                 const char *keyfile, const char *sigfile)
1957
1958 {
1959   gpg_error_t err;
1960   gcry_sexp_t s_data, s_key, s_sig;
1961   char hash[20];
1962   gcry_mpi_t tmpmpi;
1963
1964   gcry_md_hash_buffer (GCRY_MD_SHA1, hash, data, datalen);
1965   /* Note that we can't simply use %b with HASH to build the
1966      S-expression, because that might yield a negative value.  */
1967   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash, 20, NULL);
1968   if (!err)
1969     {
1970       err = gcry_sexp_build (&s_data, NULL,
1971                              "(data (flags raw)(value %m))", tmpmpi);
1972       gcry_mpi_release (tmpmpi);
1973     }
1974   if (err)
1975     die ("gcry_sexp_build failed for DSA data input: %s\n",
1976          gpg_strerror (err));
1977
1978   s_key = read_sexp_from_file (keyfile);
1979   s_sig = read_sexp_from_file (sigfile);
1980
1981   err = gcry_pk_verify (s_sig, s_data, s_key);
1982   if (!err)
1983     puts ("GOOD signature");
1984   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
1985     puts ("BAD signature");
1986   else
1987     printf ("ERROR (%s)\n", gpg_strerror (err));
1988
1989   gcry_sexp_release (s_sig);
1990   gcry_sexp_release (s_key);
1991   gcry_sexp_release (s_data);
1992 }
1993
1994
1995
1996 \f
1997 static void
1998 usage (int show_help)
1999 {
2000   if (!show_help)
2001     {
2002       fputs ("usage: " PGM
2003              " [OPTION] [FILE] (try --help for more information)\n", stderr);
2004       exit (2);
2005     }
2006   fputs
2007     ("Usage: " PGM " [OPTIONS] MODE [FILE]\n"
2008      "Run a crypto operation using hex encoded input and output.\n"
2009      "MODE:\n"
2010      "  encrypt, decrypt, digest, random, hmac-sha,\n"
2011      "  rsa-{derive,gen,sign,verify}, dsa-{pqg-gen,gen,sign,verify}\n"
2012      "OPTIONS:\n"
2013      "  --verbose        Print additional information\n"
2014      "  --binary         Input and output is in binary form\n"
2015      "  --no-fips        Do not force FIPS mode\n"
2016      "  --key KEY        Use the hex encoded KEY\n"
2017      "  --iv IV          Use the hex encoded IV\n"
2018      "  --dt DT          Use the hex encoded DT for the RNG\n"
2019      "  --algo NAME      Use algorithm NAME\n"
2020      "  --keysize N      Use a keysize of N bits\n"
2021      "  --signature NAME Take signature from file NAME\n"
2022      "  --chunk N        Read in chunks of N bytes (implies --binary)\n"
2023      "  --pkcs1          Use PKCS#1 encoding\n"
2024      "  --mct-server     Run a monte carlo test server\n"
2025      "  --loop           Enable random loop mode\n"
2026      "  --progress       Print pogress indicators\n"
2027      "  --help           Print this text\n"
2028      "With no FILE, or when FILE is -, read standard input.\n"
2029      "Report bugs to " PACKAGE_BUGREPORT ".\n" , stdout);
2030   exit (0);
2031 }
2032
2033 int
2034 main (int argc, char **argv)
2035 {
2036   int last_argc = -1;
2037   gpg_error_t err;
2038   int no_fips = 0;
2039   int progress = 0;
2040   int use_pkcs1 = 0;
2041   const char *mode_string;
2042   const char *key_string = NULL;
2043   const char *iv_string = NULL;
2044   const char *dt_string = NULL;
2045   const char *algo_string = NULL;
2046   const char *keysize_string = NULL;
2047   const char *signature_string = NULL;
2048   FILE *input;
2049   void *data;
2050   size_t datalen;
2051   size_t chunksize = 0;
2052   int mct_server = 0;
2053
2054
2055   if (argc)
2056     { argc--; argv++; }
2057
2058   while (argc && last_argc != argc )
2059     {
2060       last_argc = argc;
2061       if (!strcmp (*argv, "--"))
2062         {
2063           argc--; argv++;
2064           break;
2065         }
2066       else if (!strcmp (*argv, "--help"))
2067         {
2068           usage (1);
2069         }
2070       else if (!strcmp (*argv, "--version"))
2071         {
2072           fputs (PGM " (Libgcrypt) " PACKAGE_VERSION "\n", stdout);
2073           exit (0);
2074         }
2075       else if (!strcmp (*argv, "--verbose"))
2076         {
2077           verbose++;
2078           argc--; argv++;
2079         }
2080       else if (!strcmp (*argv, "--binary"))
2081         {
2082           binary_input = binary_output = 1;
2083           argc--; argv++;
2084         }
2085       else if (!strcmp (*argv, "--no-fips"))
2086         {
2087           no_fips++;
2088           argc--; argv++;
2089         }
2090       else if (!strcmp (*argv, "--loop"))
2091         {
2092           loop_mode = 1;
2093           argc--; argv++;
2094         }
2095       else if (!strcmp (*argv, "--progress"))
2096         {
2097           progress = 1;
2098           argc--; argv++;
2099         }
2100       else if (!strcmp (*argv, "--key"))
2101         {
2102           argc--; argv++;
2103           if (!argc)
2104             usage (0);
2105           key_string = *argv;
2106           argc--; argv++;
2107         }
2108       else if (!strcmp (*argv, "--iv"))
2109         {
2110           argc--; argv++;
2111           if (!argc)
2112             usage (0);
2113           iv_string = *argv;
2114           argc--; argv++;
2115         }
2116       else if (!strcmp (*argv, "--dt"))
2117         {
2118           argc--; argv++;
2119           if (!argc)
2120             usage (0);
2121           dt_string = *argv;
2122           argc--; argv++;
2123         }
2124       else if (!strcmp (*argv, "--algo"))
2125         {
2126           argc--; argv++;
2127           if (!argc)
2128             usage (0);
2129           algo_string = *argv;
2130           argc--; argv++;
2131         }
2132       else if (!strcmp (*argv, "--keysize"))
2133         {
2134           argc--; argv++;
2135           if (!argc)
2136             usage (0);
2137           keysize_string = *argv;
2138           argc--; argv++;
2139         }
2140       else if (!strcmp (*argv, "--signature"))
2141         {
2142           argc--; argv++;
2143           if (!argc)
2144             usage (0);
2145           signature_string = *argv;
2146           argc--; argv++;
2147         }
2148       else if (!strcmp (*argv, "--chunk"))
2149         {
2150           argc--; argv++;
2151           if (!argc)
2152             usage (0);
2153           chunksize = atoi (*argv);
2154           binary_input = binary_output = 1;
2155           argc--; argv++;
2156         }
2157       else if (!strcmp (*argv, "--pkcs1"))
2158         {
2159           use_pkcs1 = 1;
2160           argc--; argv++;
2161         }
2162       else if (!strcmp (*argv, "--mct-server"))
2163         {
2164           mct_server = 1;
2165           argc--; argv++;
2166         }
2167       else if (!strcmp (*argv, "--standalone"))
2168         {
2169           standalone_mode = 1;
2170           argc--; argv++;
2171         }
2172     }
2173
2174   if (!argc || argc > 2)
2175     usage (0);
2176   mode_string = *argv;
2177
2178   if (!strcmp (mode_string, "rsa-derive"))
2179     binary_input = 1;
2180
2181   if (argc == 2 && strcmp (argv[1], "-"))
2182     {
2183       input = fopen (argv[1], binary_input? "rb":"r");
2184       if (!input)
2185         die ("can't open `%s': %s\n", argv[1], strerror (errno));
2186     }
2187   else
2188     input = stdin;
2189
2190 #ifndef HAVE_W32_SYSTEM
2191   if (loop_mode)
2192     signal (SIGPIPE, SIG_IGN);
2193 #endif
2194
2195   if (verbose)
2196     fprintf (stderr, PGM ": started (mode=%s)\n", mode_string);
2197
2198   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
2199   if (!no_fips)
2200     gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
2201   if (!gcry_check_version ("1.4.3"))
2202     die ("Libgcrypt is not sufficient enough\n");
2203   if (verbose)
2204     fprintf (stderr, PGM ": using Libgcrypt %s\n", gcry_check_version (NULL));
2205   if (no_fips)
2206     gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
2207   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
2208
2209   /* Most operations need some input data.  */
2210   if (!chunksize
2211       && !mct_server
2212       && strcmp (mode_string, "random")
2213       && strcmp (mode_string, "rsa-gen")
2214       && strcmp (mode_string, "dsa-gen") )
2215     {
2216       data = read_file (input, !binary_input, &datalen);
2217       if (!data)
2218         die ("error reading%s input\n", binary_input?"":" and decoding");
2219       if (verbose)
2220         fprintf (stderr, PGM ": %u bytes of input data\n",
2221                  (unsigned int)datalen);
2222     }
2223   else
2224     {
2225       data = NULL;
2226       datalen = 0;
2227     }
2228
2229
2230   if (!strcmp (mode_string, "encrypt") || !strcmp (mode_string, "decrypt"))
2231     {
2232       int cipher_algo, cipher_mode;
2233       void  *iv_buffer = NULL;
2234       void *key_buffer = NULL;
2235       size_t iv_buflen,  key_buflen;
2236
2237       if (!algo_string)
2238         die ("option --algo is required in this mode\n");
2239       cipher_algo = map_openssl_cipher_name (algo_string, &cipher_mode);
2240       if (!cipher_algo)
2241         die ("cipher algorithm `%s' is not supported\n", algo_string);
2242       if (mct_server)
2243         {
2244           int iterations;
2245
2246           for (;;)
2247             {
2248               gcry_free (key_buffer); key_buffer = NULL;
2249               gcry_free (iv_buffer); iv_buffer = NULL;
2250               gcry_free (data); data = NULL;
2251               if (!(key_buffer = read_textline (input)))
2252                 {
2253                   if (feof (input))
2254                     break;
2255                   die ("no version info in input\n");
2256                 }
2257               if (atoi (key_buffer) != 1)
2258                 die ("unsupported input version %s\n", key_buffer);
2259               gcry_free (key_buffer);
2260               if (!(key_buffer = read_textline (input)))
2261                 die ("no iteration count in input\n");
2262               iterations = atoi (key_buffer);
2263               gcry_free (key_buffer);
2264               if (!(key_buffer = read_hexline (input, &key_buflen)))
2265                 die ("no key in input\n");
2266               if (!(iv_buffer = read_hexline (input, &iv_buflen)))
2267                 die ("no IV in input\n");
2268               if (!(data = read_hexline (input, &datalen)))
2269                 die ("no data in input\n");
2270               skip_to_empty_line (input);
2271
2272               run_cipher_mct_loop ((*mode_string == 'e'),
2273                                    cipher_algo, cipher_mode,
2274                                    iv_buffer, iv_buflen,
2275                                    key_buffer, key_buflen,
2276                                    data, datalen, iterations);
2277             }
2278         }
2279       else
2280         {
2281           if (cipher_mode != GCRY_CIPHER_MODE_ECB)
2282             {
2283               if (!iv_string)
2284                 die ("option --iv is required in this mode\n");
2285               iv_buffer = hex2buffer (iv_string, &iv_buflen);
2286               if (!iv_buffer)
2287                 die ("invalid value for IV\n");
2288             }
2289           else
2290             {
2291               iv_buffer = NULL;
2292               iv_buflen = 0;
2293             }
2294           if (!key_string)
2295             die ("option --key is required in this mode\n");
2296           key_buffer = hex2buffer (key_string, &key_buflen);
2297           if (!key_buffer)
2298             die ("invalid value for KEY\n");
2299
2300           run_encrypt_decrypt ((*mode_string == 'e'),
2301                                cipher_algo, cipher_mode,
2302                                iv_buffer, iv_buflen,
2303                                key_buffer, key_buflen,
2304                                data, data? datalen:chunksize, input);
2305         }
2306       gcry_free (key_buffer);
2307       gcry_free (iv_buffer);
2308     }
2309   else if (!strcmp (mode_string, "digest"))
2310     {
2311       int algo;
2312
2313       if (!algo_string)
2314         die ("option --algo is required in this mode\n");
2315       algo = gcry_md_map_name (algo_string);
2316       if (!algo)
2317         die ("digest algorithm `%s' is not supported\n", algo_string);
2318       if (!data)
2319         die ("no data available (do not use --chunk)\n");
2320
2321       run_digest (algo, data, datalen);
2322     }
2323   else if (!strcmp (mode_string, "random"))
2324     {
2325       void *context;
2326       unsigned char key[16];
2327       unsigned char seed[16];
2328       unsigned char dt[16];
2329       unsigned char buffer[16];
2330       size_t count = 0;
2331
2332       if (hex2bin (key_string, key, 16) < 0 )
2333         die ("value for --key are not 32 hex digits\n");
2334       if (hex2bin (iv_string, seed, 16) < 0 )
2335         die ("value for --iv are not 32 hex digits\n");
2336       if (hex2bin (dt_string, dt, 16) < 0 )
2337         die ("value for --dt are not 32 hex digits\n");
2338
2339       /* The flag value 1 disables the dup check, so that the RNG
2340          returns all generated data.  */
2341       err = init_external_rng_test (&context, 1, key, 16, seed, 16, dt, 16);
2342       if (err)
2343         die ("init external RNG test failed: %s\n", gpg_strerror (err));
2344
2345       do
2346         {
2347           err = run_external_rng_test (context, buffer, sizeof buffer);
2348           if (err)
2349             die ("running external RNG test failed: %s\n", gpg_strerror (err));
2350           print_buffer (buffer, sizeof buffer);
2351           if (progress)
2352             {
2353               if (!(++count % 1000))
2354                 fprintf (stderr, PGM ": %lu random bytes so far\n",
2355                          (unsigned long int)(count * sizeof buffer));
2356             }
2357         }
2358       while (loop_mode);
2359
2360       if (progress)
2361         fprintf (stderr, PGM ": %lu random bytes\n",
2362                  (unsigned long int)(count * sizeof buffer));
2363
2364       deinit_external_rng_test (context);
2365     }
2366   else if (!strcmp (mode_string, "hmac-sha"))
2367     {
2368       int algo;
2369       void  *key_buffer;
2370       size_t key_buflen;
2371
2372       if (!data)
2373         die ("no data available (do not use --chunk)\n");
2374       if (!algo_string)
2375         die ("option --algo is required in this mode\n");
2376       switch (atoi (algo_string))
2377         {
2378         case 1:   algo = GCRY_MD_SHA1; break;
2379         case 224: algo = GCRY_MD_SHA224; break;
2380         case 256: algo = GCRY_MD_SHA256; break;
2381         case 384: algo = GCRY_MD_SHA384; break;
2382         case 512: algo = GCRY_MD_SHA512; break;
2383         default:  algo = 0; break;
2384         }
2385       if (!algo)
2386         die ("no digest algorithm found for hmac type `%s'\n", algo_string);
2387       if (!key_string)
2388         die ("option --key is required in this mode\n");
2389       key_buffer = hex2buffer (key_string, &key_buflen);
2390       if (!key_buffer)
2391         die ("invalid value for KEY\n");
2392
2393       run_hmac (algo, key_buffer, key_buflen, data, datalen);
2394
2395       gcry_free (key_buffer);
2396     }
2397   else if (!strcmp (mode_string, "rsa-derive"))
2398     {
2399       if (!data)
2400         die ("no data available (do not use --chunk)\n");
2401       run_rsa_derive (data, datalen);
2402     }
2403   else if (!strcmp (mode_string, "rsa-gen"))
2404     {
2405       int keysize;
2406
2407       if (!binary_output)
2408         base64_output = 1;
2409
2410       keysize = keysize_string? atoi (keysize_string) : 0;
2411       if (keysize < 128 || keysize > 16384)
2412         die ("invalid keysize specified; needs to be 128 .. 16384\n");
2413       run_rsa_gen (keysize, 65537);
2414     }
2415   else if (!strcmp (mode_string, "rsa-sign"))
2416     {
2417       int algo;
2418
2419       if (!key_string)
2420         die ("option --key is required in this mode\n");
2421       if (access (key_string, R_OK))
2422         die ("option --key needs to specify an existing keyfile\n");
2423       if (!algo_string)
2424         die ("option --algo is required in this mode\n");
2425       algo = gcry_md_map_name (algo_string);
2426       if (!algo)
2427         die ("digest algorithm `%s' is not supported\n", algo_string);
2428       if (!data)
2429         die ("no data available (do not use --chunk)\n");
2430
2431       run_rsa_sign (data, datalen, algo, use_pkcs1, key_string);
2432
2433     }
2434   else if (!strcmp (mode_string, "rsa-verify"))
2435     {
2436       int algo;
2437
2438       if (!key_string)
2439         die ("option --key is required in this mode\n");
2440       if (access (key_string, R_OK))
2441         die ("option --key needs to specify an existing keyfile\n");
2442       if (!algo_string)
2443         die ("option --algo is required in this mode\n");
2444       algo = gcry_md_map_name (algo_string);
2445       if (!algo)
2446         die ("digest algorithm `%s' is not supported\n", algo_string);
2447       if (!data)
2448         die ("no data available (do not use --chunk)\n");
2449       if (!signature_string)
2450         die ("option --signature is required in this mode\n");
2451       if (access (signature_string, R_OK))
2452         die ("option --signature needs to specify an existing file\n");
2453
2454       run_rsa_verify (data, datalen, algo, use_pkcs1, key_string,
2455                       signature_string);
2456
2457     }
2458   else if (!strcmp (mode_string, "dsa-pqg-gen"))
2459     {
2460       int keysize;
2461
2462       keysize = keysize_string? atoi (keysize_string) : 0;
2463       if (keysize < 1024 || keysize > 3072)
2464         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
2465       run_dsa_pqg_gen (keysize, datalen? data:NULL, datalen);
2466     }
2467   else if (!strcmp (mode_string, "dsa-gen"))
2468     {
2469       int keysize;
2470
2471       keysize = keysize_string? atoi (keysize_string) : 0;
2472       if (keysize < 1024 || keysize > 3072)
2473         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
2474       if (!key_string)
2475         die ("option --key is required in this mode\n");
2476       run_dsa_gen (keysize, key_string);
2477     }
2478   else if (!strcmp (mode_string, "dsa-sign"))
2479     {
2480       if (!key_string)
2481         die ("option --key is required in this mode\n");
2482       if (access (key_string, R_OK))
2483         die ("option --key needs to specify an existing keyfile\n");
2484       if (!data)
2485         die ("no data available (do not use --chunk)\n");
2486
2487       run_dsa_sign (data, datalen, key_string);
2488     }
2489   else if (!strcmp (mode_string, "dsa-verify"))
2490     {
2491       if (!key_string)
2492         die ("option --key is required in this mode\n");
2493       if (access (key_string, R_OK))
2494         die ("option --key needs to specify an existing keyfile\n");
2495       if (!data)
2496         die ("no data available (do not use --chunk)\n");
2497       if (!signature_string)
2498         die ("option --signature is required in this mode\n");
2499       if (access (signature_string, R_OK))
2500         die ("option --signature needs to specify an existing file\n");
2501
2502       run_dsa_verify (data, datalen, key_string, signature_string);
2503     }
2504   else
2505     usage (0);
2506
2507   gcry_free (data);
2508
2509   /* Because Libgcrypt does not enforce FIPS mode in all cases we let
2510      the process die if Libgcrypt is not anymore in FIPS mode after
2511      the actual operation.  */
2512   if (!no_fips && !gcry_fips_mode_active ())
2513     die ("FIPS mode is not anymore active\n");
2514
2515   if (verbose)
2516     fputs (PGM ": ready\n", stderr);
2517
2518   return 0;
2519 }