tests: Add new --pss option to fipsdrv
[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 /* Generate RSA key using the S-expression in (DATA,DATALEN).  This
1344    S-expression is used directly as input to gcry_pk_genkey.  The
1345    result is printed to stdout with one parameter per line in hex
1346    format and in this order: e, p, q, n, d.  */
1347 static void
1348 run_rsa_keygen (const void *data, size_t datalen, int test)
1349 {
1350   gpg_error_t err;
1351   gcry_sexp_t s_keyspec, s_key, s_top, l1;
1352   gcry_mpi_t mpi;
1353   const char *parmlist;
1354   int idx;
1355
1356   if (!datalen)
1357     err = gpg_error (GPG_ERR_NO_DATA);
1358   else
1359     err = gcry_sexp_new (&s_keyspec, data, datalen, 1);
1360   if (err)
1361     die ("gcry_sexp_new failed for RSA key generation: %s\n",
1362          gpg_strerror (err));
1363
1364   err = gcry_pk_genkey (&s_key, s_keyspec);
1365
1366   gcry_sexp_release (s_keyspec);
1367
1368   if (test) {
1369         if (err)
1370                 printf("F\n");
1371         else {
1372                 gcry_sexp_release (s_key);
1373                 printf("P\n");
1374         }
1375         return;
1376   }
1377
1378   if (err)
1379     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
1380
1381   parmlist = "epqnd";
1382
1383   /* Parse and print the parameters.  */
1384   l1 = gcry_sexp_find_token (s_key, "private-key", 0);
1385   s_top = gcry_sexp_find_token (l1, "rsa", 0);
1386   gcry_sexp_release (l1);
1387   if (!s_top)
1388     die ("private-key part not found in result\n");
1389
1390   for (idx=0; parmlist[idx]; idx++)
1391     {
1392       l1 = gcry_sexp_find_token (s_top, parmlist+idx, 1);
1393       mpi = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1394       gcry_sexp_release (l1);
1395       if (!mpi)
1396         die ("parameter %c missing in private-key\n", parmlist[idx]);
1397       print_mpi_line (mpi, 1);
1398       gcry_mpi_release (mpi);
1399     }
1400
1401   gcry_sexp_release (s_top);
1402   gcry_sexp_release (s_key);
1403 }
1404
1405
1406 \f
1407 static size_t
1408 compute_tag_length (size_t n)
1409 {
1410   int needed = 0;
1411
1412   if (n < 128)
1413     needed += 2; /* Tag and one length byte.  */
1414   else if (n < 256)
1415     needed += 3; /* Tag, number of length bytes, 1 length byte.  */
1416   else if (n < 65536)
1417     needed += 4; /* Tag, number of length bytes, 2 length bytes.  */
1418   else
1419     die ("DER object too long to encode\n");
1420
1421   return needed;
1422 }
1423
1424 static unsigned char *
1425 store_tag_length (unsigned char *p, int tag, size_t n)
1426 {
1427   if (tag == TAG_SEQUENCE)
1428     tag |= 0x20; /* constructed */
1429
1430   *p++ = tag;
1431   if (n < 128)
1432     *p++ = n;
1433   else if (n < 256)
1434     {
1435       *p++ = 0x81;
1436       *p++ = n;
1437     }
1438   else if (n < 65536)
1439     {
1440       *p++ = 0x82;
1441       *p++ = n >> 8;
1442       *p++ = n;
1443     }
1444
1445   return p;
1446 }
1447
1448
1449 /* Generate an RSA key of size KEYSIZE using the public exponent
1450    PUBEXP and print it to stdout in the OpenSSL format.  The format
1451    is:
1452
1453        SEQUENCE {
1454          INTEGER (0)  -- Unknown constant.
1455          INTEGER      -- n
1456          INTEGER      -- e
1457          INTEGER      -- d
1458          INTEGER      -- p
1459          INTEGER      -- q      (with p < q)
1460          INTEGER      -- dmp1 = d mod (p-1)
1461          INTEGER      -- dmq1 = d mod (q-1)
1462          INTEGER      -- u    = p^{-1} mod q
1463        }
1464
1465 */
1466 static void
1467 run_rsa_gen (int keysize, int pubexp)
1468 {
1469   gpg_error_t err;
1470   gcry_sexp_t keyspec, key, l1;
1471   const char keyelems[] = "nedpq..u";
1472   gcry_mpi_t keyparms[8];
1473   size_t     keyparmslen[8];
1474   int idx;
1475   size_t derlen, needed, n;
1476   unsigned char *derbuf, *der;
1477
1478   err = gcry_sexp_build (&keyspec, NULL,
1479                          "(genkey (rsa (nbits %d)(rsa-use-e %d)))",
1480                          keysize, pubexp);
1481   if (err)
1482     die ("gcry_sexp_build failed for RSA key generation: %s\n",
1483          gpg_strerror (err));
1484
1485   err = gcry_pk_genkey (&key, keyspec);
1486   if (err)
1487     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
1488
1489   gcry_sexp_release (keyspec);
1490
1491   l1 = gcry_sexp_find_token (key, "private-key", 0);
1492   if (!l1)
1493     die ("private key not found in genkey result\n");
1494   gcry_sexp_release (key);
1495   key = l1;
1496
1497   l1 = gcry_sexp_find_token (key, "rsa", 0);
1498   if (!l1)
1499     die ("returned private key not formed as expected\n");
1500   gcry_sexp_release (key);
1501   key = l1;
1502
1503   /* Extract the parameters from the S-expression and store them in a
1504      well defined order in KEYPARMS.  */
1505   for (idx=0; idx < DIM(keyparms); idx++)
1506     {
1507       if (keyelems[idx] == '.')
1508         {
1509           keyparms[idx] = gcry_mpi_new (0);
1510           continue;
1511         }
1512       l1 = gcry_sexp_find_token (key, keyelems+idx, 1);
1513       if (!l1)
1514         die ("no %c parameter in returned private key\n", keyelems[idx]);
1515       keyparms[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1516       if (!keyparms[idx])
1517         die ("no value for %c parameter in returned private key\n",
1518              keyelems[idx]);
1519       gcry_sexp_release (l1);
1520     }
1521
1522   gcry_sexp_release (key);
1523
1524   /* Check that p < q; if not swap p and q and recompute u.  */
1525   if (gcry_mpi_cmp (keyparms[3], keyparms[4]) > 0)
1526     {
1527       gcry_mpi_swap (keyparms[3], keyparms[4]);
1528       gcry_mpi_invm (keyparms[7], keyparms[3], keyparms[4]);
1529     }
1530
1531   /* Compute the additional parameters.  */
1532   gcry_mpi_sub_ui (keyparms[5], keyparms[3], 1);
1533   gcry_mpi_mod (keyparms[5], keyparms[2], keyparms[5]);
1534   gcry_mpi_sub_ui (keyparms[6], keyparms[4], 1);
1535   gcry_mpi_mod (keyparms[6], keyparms[2], keyparms[6]);
1536
1537   /* Compute the length of the DER encoding.  */
1538   needed = compute_tag_length (1) + 1;
1539   for (idx=0; idx < DIM(keyparms); idx++)
1540     {
1541       err = gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &n, keyparms[idx]);
1542       if (err)
1543         die ("error formatting parameter: %s\n", gpg_strerror (err));
1544       keyparmslen[idx] = n;
1545       needed += compute_tag_length (n) + n;
1546     }
1547
1548   /* Store the key parameters. */
1549   derlen = compute_tag_length (needed) + needed;
1550   der = derbuf = gcry_xmalloc (derlen);
1551
1552   der = store_tag_length (der, TAG_SEQUENCE, needed);
1553   der = store_tag_length (der, TAG_INTEGER, 1);
1554   *der++ = 0;
1555   for (idx=0; idx < DIM(keyparms); idx++)
1556     {
1557       der = store_tag_length (der, TAG_INTEGER, keyparmslen[idx]);
1558       err = gcry_mpi_print (GCRYMPI_FMT_STD, der,
1559                            keyparmslen[idx], NULL, keyparms[idx]);
1560       if (err)
1561         die ("error formatting parameter: %s\n", gpg_strerror (err));
1562       der += keyparmslen[idx];
1563     }
1564
1565   /* Print the stuff.  */
1566   for (idx=0; idx < DIM(keyparms); idx++)
1567     gcry_mpi_release (keyparms[idx]);
1568
1569   assert (der - derbuf == derlen);
1570
1571   if (base64_output)
1572     puts ("-----BEGIN RSA PRIVATE KEY-----");
1573   print_buffer (derbuf, derlen);
1574   if (base64_output)
1575     puts ("-----END RSA PRIVATE KEY-----");
1576
1577   gcry_free (derbuf);
1578 }
1579
1580
1581 \f
1582 /* Sign DATA of length DATALEN using the key taken from the PEM
1583    encoded KEYFILE and the hash algorithm HASHALGO.  */
1584 static void
1585 run_rsa_sign (const void *data, size_t datalen,
1586               int hashalgo, int pkcs1, int pss, const char *keyfile)
1587
1588 {
1589   gpg_error_t err;
1590   gcry_sexp_t s_data, s_key, s_sig, s_tmp;
1591   gcry_mpi_t sig_mpi = NULL;
1592   unsigned char *outbuf;
1593   size_t outlen;
1594
1595 /*   showhex ("D", data, datalen); */
1596   if (pkcs1)
1597     {
1598       unsigned char hash[64];
1599       unsigned int hashsize;
1600
1601       hashsize = gcry_md_get_algo_dlen (hashalgo);
1602       if (!hashsize || hashsize > sizeof hash)
1603         die ("digest too long for buffer or unknown hash algorithm\n");
1604       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
1605       err = gcry_sexp_build (&s_data, NULL,
1606                              "(data (flags pkcs1)(hash %s %b))",
1607                              gcry_md_algo_name (hashalgo),
1608                              (int)hashsize, hash);
1609     }
1610   else if (pss)
1611     {
1612       unsigned char hash[64];
1613       unsigned int hashsize;
1614
1615       hashsize = gcry_md_get_algo_dlen (hashalgo);
1616       if (!hashsize || hashsize > sizeof hash)
1617         die ("digest too long for buffer or unknown hash algorithm\n");
1618       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
1619       err = gcry_sexp_build (&s_data, NULL,
1620                              "(data (flags pss)(salt-length #00#)(hash %s %b))",
1621                              gcry_md_algo_name (hashalgo),
1622                              (int)hashsize, hash);
1623     }
1624   else
1625     {
1626       gcry_mpi_t tmp;
1627
1628       err = gcry_mpi_scan (&tmp, GCRYMPI_FMT_USG, data, datalen,NULL);
1629       if (!err)
1630         {
1631           err = gcry_sexp_build (&s_data, NULL,
1632                                  "(data (flags raw)(value %m))", tmp);
1633           gcry_mpi_release (tmp);
1634         }
1635     }
1636   if (err)
1637     die ("gcry_sexp_build failed for RSA data input: %s\n",
1638          gpg_strerror (err));
1639
1640   s_key = read_private_key_file (keyfile, 0);
1641
1642   err = gcry_pk_sign (&s_sig, s_data, s_key);
1643   if (err)
1644     {
1645       gcry_sexp_release (read_private_key_file (keyfile, 1));
1646       die ("gcry_pk_signed failed (datalen=%d,keyfile=%s): %s\n",
1647            (int)datalen, keyfile, gpg_strerror (err));
1648     }
1649   gcry_sexp_release (s_key);
1650   gcry_sexp_release (s_data);
1651
1652   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
1653   if (s_tmp)
1654     {
1655       gcry_sexp_release (s_sig);
1656       s_sig = s_tmp;
1657       s_tmp = gcry_sexp_find_token (s_sig, "rsa", 0);
1658       if (s_tmp)
1659         {
1660           gcry_sexp_release (s_sig);
1661           s_sig = s_tmp;
1662           s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
1663           if (s_tmp)
1664             {
1665               gcry_sexp_release (s_sig);
1666               s_sig = s_tmp;
1667               sig_mpi = gcry_sexp_nth_mpi (s_sig, 1, GCRYMPI_FMT_USG);
1668             }
1669         }
1670     }
1671   gcry_sexp_release (s_sig);
1672
1673   if (!sig_mpi)
1674     die ("no value in returned S-expression\n");
1675   err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &outbuf, &outlen, sig_mpi);
1676   if (err)
1677     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
1678   gcry_mpi_release (sig_mpi);
1679
1680   print_buffer (outbuf, outlen);
1681   gcry_free (outbuf);
1682 }
1683
1684
1685 \f
1686 /* Verify DATA of length DATALEN using the public key taken from the
1687    PEM encoded KEYFILE and the hash algorithm HASHALGO against the
1688    binary signature in SIGFILE.  */
1689 static void
1690 run_rsa_verify (const void *data, size_t datalen, int hashalgo, int pkcs1,
1691                 int pss, const char *keyfile, const char *sigfile)
1692
1693 {
1694   gpg_error_t err;
1695   gcry_sexp_t s_data, s_key, s_sig;
1696
1697   if (pkcs1)
1698     {
1699       unsigned char hash[64];
1700       unsigned int hashsize;
1701
1702       hashsize = gcry_md_get_algo_dlen (hashalgo);
1703       if (!hashsize || hashsize > sizeof hash)
1704         die ("digest too long for buffer or unknown hash algorithm\n");
1705       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
1706       err = gcry_sexp_build (&s_data, NULL,
1707                              "(data (flags pkcs1)(hash %s %b))",
1708                              gcry_md_algo_name (hashalgo),
1709                              (int)hashsize, hash);
1710     }
1711   else if (pss)
1712     {
1713       unsigned char hash[64];
1714       unsigned int hashsize;
1715
1716       hashsize = gcry_md_get_algo_dlen (hashalgo);
1717       if (!hashsize || hashsize > sizeof hash)
1718         die ("digest too long for buffer or unknown hash algorithm\n");
1719       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
1720       err = gcry_sexp_build (&s_data, NULL,
1721                              "(data (flags pss)(salt-length #00#)(hash %s %b))",
1722                              gcry_md_algo_name (hashalgo),
1723                              (int)hashsize, hash);
1724     }
1725   else
1726     {
1727       gcry_mpi_t tmp;
1728
1729       err = gcry_mpi_scan (&tmp, GCRYMPI_FMT_USG, data, datalen,NULL);
1730       if (!err)
1731         {
1732           err = gcry_sexp_build (&s_data, NULL,
1733                                  "(data (flags raw)(value %m))", tmp);
1734           gcry_mpi_release (tmp);
1735         }
1736     }
1737   if (err)
1738     die ("gcry_sexp_build failed for RSA data input: %s\n",
1739          gpg_strerror (err));
1740
1741   s_key = read_public_key_file (keyfile, 0);
1742
1743   s_sig = read_sig_file (sigfile);
1744
1745   err = gcry_pk_verify (s_sig, s_data, s_key);
1746   if (!err)
1747     puts ("GOOD signature");
1748   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
1749     puts ("BAD signature");
1750   else
1751     printf ("ERROR (%s)\n", gpg_strerror (err));
1752
1753   gcry_sexp_release (s_sig);
1754   gcry_sexp_release (s_key);
1755   gcry_sexp_release (s_data);
1756 }
1757
1758
1759 \f
1760 /* Generate a DSA key of size KEYSIZE and return the complete
1761    S-expression.  */
1762 static gcry_sexp_t
1763 dsa_gen (int keysize)
1764 {
1765   gpg_error_t err;
1766   gcry_sexp_t keyspec, key;
1767
1768   err = gcry_sexp_build (&keyspec, NULL,
1769                          "(genkey (dsa (nbits %d)(use-fips186-2)))",
1770                          keysize);
1771   if (err)
1772     die ("gcry_sexp_build failed for DSA key generation: %s\n",
1773          gpg_strerror (err));
1774
1775   err = gcry_pk_genkey (&key, keyspec);
1776   if (err)
1777     die ("gcry_pk_genkey failed for DSA: %s\n", gpg_strerror (err));
1778
1779   gcry_sexp_release (keyspec);
1780
1781   return key;
1782 }
1783
1784
1785 /* Generate a DSA key of size KEYSIZE and return the complete
1786    S-expression.  */
1787 static gcry_sexp_t
1788 dsa_gen_with_seed (int keysize, const void *seed, size_t seedlen)
1789 {
1790   gpg_error_t err;
1791   gcry_sexp_t keyspec, key;
1792
1793   err = gcry_sexp_build (&keyspec, NULL,
1794                          "(genkey"
1795                          "  (dsa"
1796                          "    (nbits %d)"
1797                          "    (use-fips186-2)"
1798                          "    (derive-parms"
1799                          "      (seed %b))))",
1800                          keysize, (int)seedlen, seed);
1801   if (err)
1802     die ("gcry_sexp_build failed for DSA key generation: %s\n",
1803          gpg_strerror (err));
1804
1805   err = gcry_pk_genkey (&key, keyspec);
1806   if (err)
1807     die ("gcry_pk_genkey failed for DSA: %s\n", gpg_strerror (err));
1808
1809   gcry_sexp_release (keyspec);
1810
1811   return key;
1812 }
1813
1814
1815 /* Generate an ECDSA key on the specified curve and return the complete
1816    S-expression. */
1817 static gcry_sexp_t
1818 ecdsa_gen_key (const char *curve)
1819 {
1820   gpg_error_t err;
1821   gcry_sexp_t keyspec, key;
1822
1823   err = gcry_sexp_build (&keyspec, NULL,
1824                          "(genkey"
1825                          "  (ecc"
1826                          "    (use-fips186)"
1827                          "    (curve %s)))",
1828                          curve);
1829   if (err)
1830     die ("gcry_sexp_build failed for ECDSA key generation: %s\n",
1831          gpg_strerror (err));
1832   err = gcry_pk_genkey (&key, keyspec);
1833   if (err)
1834     die ("gcry_pk_genkey failed for ECDSA: %s\n", gpg_strerror (err));
1835
1836   gcry_sexp_release (keyspec);
1837
1838   return key;
1839 }
1840
1841
1842 /* Print the domain parameter as well as the derive information.  KEY
1843    is the complete key as returned by dsa_gen.  We print to stdout
1844    with one parameter per line in hex format using this order: p, q,
1845    g, seed, counter, h. */
1846 static void
1847 print_dsa_domain_parameters (gcry_sexp_t key)
1848 {
1849   gcry_sexp_t l1, l2;
1850   gcry_mpi_t mpi;
1851   int idx;
1852   const void *data;
1853   size_t datalen;
1854   char *string;
1855
1856   l1 = gcry_sexp_find_token (key, "public-key", 0);
1857   if (!l1)
1858     die ("public key not found in genkey result\n");
1859
1860   l2 = gcry_sexp_find_token (l1, "dsa", 0);
1861   if (!l2)
1862     die ("returned public key not formed as expected\n");
1863   gcry_sexp_release (l1);
1864   l1 = l2;
1865
1866   /* Extract the parameters from the S-expression and print them to stdout.  */
1867   for (idx=0; "pqg"[idx]; idx++)
1868     {
1869       l2 = gcry_sexp_find_token (l1, "pqg"+idx, 1);
1870       if (!l2)
1871         die ("no %c parameter in returned public key\n", "pqg"[idx]);
1872       mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1873       if (!mpi)
1874         die ("no value for %c parameter in returned public key\n","pqg"[idx]);
1875       gcry_sexp_release (l2);
1876       if (standalone_mode)
1877         printf ("%c = ", "PQG"[idx]);
1878       print_mpi_line (mpi, 1);
1879       gcry_mpi_release (mpi);
1880     }
1881   gcry_sexp_release (l1);
1882
1883   /* Extract the seed values.  */
1884   l1 = gcry_sexp_find_token (key, "misc-key-info", 0);
1885   if (!l1)
1886     die ("misc-key-info not found in genkey result\n");
1887
1888   l2 = gcry_sexp_find_token (l1, "seed-values", 0);
1889   if (!l2)
1890     die ("no seed-values in returned key\n");
1891   gcry_sexp_release (l1);
1892   l1 = l2;
1893
1894   l2 = gcry_sexp_find_token (l1, "seed", 0);
1895   if (!l2)
1896     die ("no seed value in returned key\n");
1897   data = gcry_sexp_nth_data (l2, 1, &datalen);
1898   if (!data)
1899     die ("no seed value in returned key\n");
1900   if (standalone_mode)
1901     printf ("Seed = ");
1902   print_data_line (data, datalen);
1903   gcry_sexp_release (l2);
1904
1905   l2 = gcry_sexp_find_token (l1, "counter", 0);
1906   if (!l2)
1907     die ("no counter value in returned key\n");
1908   string = gcry_sexp_nth_string (l2, 1);
1909   if (!string)
1910     die ("no counter value in returned key\n");
1911   if (standalone_mode)
1912     printf ("c = %ld\n", strtoul (string, NULL, 10));
1913   else
1914     printf ("%lX\n", strtoul (string, NULL, 10));
1915   gcry_free (string);
1916   gcry_sexp_release (l2);
1917
1918   l2 = gcry_sexp_find_token (l1, "h", 0);
1919   if (!l2)
1920     die ("no n value in returned key\n");
1921   mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1922   if (!mpi)
1923     die ("no h value in returned key\n");
1924   if (standalone_mode)
1925     printf ("H = ");
1926   print_mpi_line (mpi, 1);
1927   gcry_mpi_release (mpi);
1928   gcry_sexp_release (l2);
1929
1930   gcry_sexp_release (l1);
1931 }
1932
1933
1934 /* Print public key Q (in octet-string format) and private key d.
1935    KEY is the complete key as returned by ecdsa_gen_key.
1936    with one parameter per line in hex format using this order: d, Q. */
1937 static void
1938 print_ecdsa_dq (gcry_sexp_t key)
1939 {
1940   gcry_sexp_t l1, l2;
1941   gcry_mpi_t mpi;
1942   int idx;
1943
1944   l1 = gcry_sexp_find_token (key, "private-key", 0);
1945   if (!l1)
1946     die ("private key not found in genkey result\n");
1947
1948   l2 = gcry_sexp_find_token (l1, "ecc", 0);
1949   if (!l2)
1950     die ("returned private key not formed as expected\n");
1951   gcry_sexp_release (l1);
1952   l1 = l2;
1953
1954   /* Extract the parameters from the S-expression and print them to stdout.  */
1955   for (idx=0; "dq"[idx]; idx++)
1956     {
1957       l2 = gcry_sexp_find_token (l1, "dq"+idx, 1);
1958       if (!l2)
1959         die ("no %c parameter in returned public key\n", "dq"[idx]);
1960       mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1961       if (!mpi)
1962         die ("no value for %c parameter in returned private key\n","dq"[idx]);
1963       gcry_sexp_release (l2);
1964       if (standalone_mode)
1965         printf ("%c = ", "dQ"[idx]);
1966       print_mpi_line (mpi, 1);
1967       gcry_mpi_release (mpi);
1968     }
1969
1970   gcry_sexp_release (l1);
1971 }
1972
1973
1974 /* Generate DSA domain parameters for a modulus size of KEYSIZE.  The
1975    result is printed to stdout with one parameter per line in hex
1976    format and in this order: p, q, g, seed, counter, h.  If SEED is
1977    not NULL this seed value will be used for the generation.  */
1978 static void
1979 run_dsa_pqg_gen (int keysize, const void *seed, size_t seedlen)
1980 {
1981   gcry_sexp_t key;
1982
1983   if (seed)
1984     key = dsa_gen_with_seed (keysize, seed, seedlen);
1985   else
1986     key = dsa_gen (keysize);
1987   print_dsa_domain_parameters (key);
1988   gcry_sexp_release (key);
1989 }
1990
1991
1992 /* Generate a DSA key of size of KEYSIZE and write the private key to
1993    FILENAME.  Also write the parameters to stdout in the same way as
1994    run_dsa_pqg_gen.  */
1995 static void
1996 run_dsa_gen (int keysize, const char *filename)
1997 {
1998   gcry_sexp_t key, private_key;
1999   FILE *fp;
2000
2001   key = dsa_gen (keysize);
2002   private_key = gcry_sexp_find_token (key, "private-key", 0);
2003   if (!private_key)
2004     die ("private key not found in genkey result\n");
2005   print_dsa_domain_parameters (key);
2006
2007   fp = fopen (filename, "wb");
2008   if (!fp)
2009     die ("can't create `%s': %s\n", filename, strerror (errno));
2010   print_sexp (private_key, fp);
2011   fclose (fp);
2012
2013   gcry_sexp_release (private_key);
2014   gcry_sexp_release (key);
2015 }
2016
2017
2018 \f
2019 /* Sign DATA of length DATALEN using the key taken from the S-expression
2020    encoded KEYFILE. */
2021 static void
2022 run_dsa_sign (const void *data, size_t datalen, const char *keyfile)
2023
2024 {
2025   gpg_error_t err;
2026   gcry_sexp_t s_data, s_key, s_sig, s_tmp, s_tmp2;
2027   char hash[20];
2028   gcry_mpi_t tmpmpi;
2029
2030   gcry_md_hash_buffer (GCRY_MD_SHA1, hash, data, datalen);
2031   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash, 20, NULL);
2032   if (!err)
2033     {
2034       err = gcry_sexp_build (&s_data, NULL,
2035                              "(data (flags raw)(value %m))", tmpmpi);
2036       gcry_mpi_release (tmpmpi);
2037     }
2038   if (err)
2039     die ("gcry_sexp_build failed for DSA data input: %s\n",
2040          gpg_strerror (err));
2041
2042   s_key = read_sexp_from_file (keyfile);
2043
2044   err = gcry_pk_sign (&s_sig, s_data, s_key);
2045   if (err)
2046     {
2047       gcry_sexp_release (read_private_key_file (keyfile, 1));
2048       die ("gcry_pk_signed failed (datalen=%d,keyfile=%s): %s\n",
2049            (int)datalen, keyfile, gpg_strerror (err));
2050     }
2051   gcry_sexp_release (s_data);
2052
2053   /* We need to return the Y parameter first.  */
2054   s_tmp = gcry_sexp_find_token (s_key, "private-key", 0);
2055   if (!s_tmp)
2056     die ("private key part not found in provided key\n");
2057
2058   s_tmp2 = gcry_sexp_find_token (s_tmp, "dsa", 0);
2059   if (!s_tmp2)
2060     die ("private key part is not a DSA key\n");
2061   gcry_sexp_release (s_tmp);
2062
2063   s_tmp = gcry_sexp_find_token (s_tmp2, "y", 0);
2064   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
2065   if (!tmpmpi)
2066     die ("no y parameter in DSA key\n");
2067   print_mpi_line (tmpmpi, 1);
2068   gcry_mpi_release (tmpmpi);
2069   gcry_sexp_release (s_tmp);
2070
2071   gcry_sexp_release (s_key);
2072
2073
2074   /* Now return the actual signature.  */
2075   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
2076   if (!s_tmp)
2077     die ("no sig-val element in returned S-expression\n");
2078
2079   gcry_sexp_release (s_sig);
2080   s_sig = s_tmp;
2081   s_tmp = gcry_sexp_find_token (s_sig, "dsa", 0);
2082   if (!s_tmp)
2083     die ("no dsa element in returned S-expression\n");
2084
2085   gcry_sexp_release (s_sig);
2086   s_sig = s_tmp;
2087
2088   s_tmp = gcry_sexp_find_token (s_sig, "r", 0);
2089   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
2090   if (!tmpmpi)
2091     die ("no r parameter in returned S-expression\n");
2092   print_mpi_line (tmpmpi, 1);
2093   gcry_mpi_release (tmpmpi);
2094   gcry_sexp_release (s_tmp);
2095
2096   s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
2097   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
2098   if (!tmpmpi)
2099     die ("no s parameter in returned S-expression\n");
2100   print_mpi_line (tmpmpi, 1);
2101   gcry_mpi_release (tmpmpi);
2102   gcry_sexp_release (s_tmp);
2103
2104   gcry_sexp_release (s_sig);
2105 }
2106
2107
2108 \f
2109 /* Verify DATA of length DATALEN using the public key taken from the
2110    S-expression in KEYFILE against the S-expression formatted
2111    signature in SIGFILE.  */
2112 static void
2113 run_dsa_verify (const void *data, size_t datalen,
2114                 const char *keyfile, const char *sigfile)
2115
2116 {
2117   gpg_error_t err;
2118   gcry_sexp_t s_data, s_key, s_sig;
2119   char hash[20];
2120   gcry_mpi_t tmpmpi;
2121
2122   gcry_md_hash_buffer (GCRY_MD_SHA1, hash, data, datalen);
2123   /* Note that we can't simply use %b with HASH to build the
2124      S-expression, because that might yield a negative value.  */
2125   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash, 20, NULL);
2126   if (!err)
2127     {
2128       err = gcry_sexp_build (&s_data, NULL,
2129                              "(data (flags raw)(value %m))", tmpmpi);
2130       gcry_mpi_release (tmpmpi);
2131     }
2132   if (err)
2133     die ("gcry_sexp_build failed for DSA data input: %s\n",
2134          gpg_strerror (err));
2135
2136   s_key = read_sexp_from_file (keyfile);
2137   s_sig = read_sexp_from_file (sigfile);
2138
2139   err = gcry_pk_verify (s_sig, s_data, s_key);
2140   if (!err)
2141     puts ("GOOD signature");
2142   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
2143     puts ("BAD signature");
2144   else
2145     printf ("ERROR (%s)\n", gpg_strerror (err));
2146
2147   gcry_sexp_release (s_sig);
2148   gcry_sexp_release (s_key);
2149   gcry_sexp_release (s_data);
2150 }
2151
2152
2153 \f
2154 /* Sign DATA of length DATALEN using the key taken from the S-expression
2155    encoded KEYFILE. */
2156 static void
2157 run_ecdsa_sign (const void *data, size_t datalen,
2158                 const char *keyfile, const int algo)
2159
2160 {
2161   gpg_error_t err;
2162   gcry_sexp_t s_data, s_key, s_sig, s_tmp;
2163   char hash[128];
2164   gcry_mpi_t tmpmpi;
2165
2166   s_key = read_sexp_from_file (keyfile);
2167
2168   gcry_md_hash_buffer (algo, hash, data, datalen);
2169   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash,
2170                        gcry_md_get_algo_dlen(algo), NULL);
2171   if (!err)
2172     {
2173       err = gcry_sexp_build (&s_data, NULL,
2174                              "(data (flags raw)(hash %s %M))",
2175                              gcry_md_algo_name(algo), tmpmpi);
2176       gcry_mpi_release (tmpmpi);
2177     }
2178   if (err)
2179     die ("gcry_sexp_build failed for ECDSA data input: %s\n",
2180          gpg_strerror (err));
2181
2182   err = gcry_pk_sign (&s_sig, s_data, s_key);
2183   if (err)
2184     {
2185       die ("gcry_pk_signed failed: %s\n", gpg_strerror (err));
2186     }
2187   gcry_sexp_release (s_data);
2188   gcry_sexp_release (s_key);
2189
2190   /* Now return the actual signature.  */
2191   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
2192   if (!s_tmp)
2193     die ("no sig-val element in returned S-expression\n");
2194
2195   gcry_sexp_release (s_sig);
2196   s_sig = s_tmp;
2197   s_tmp = gcry_sexp_find_token (s_sig, "ecdsa", 0);
2198   if (!s_tmp)
2199     die ("no ecdsa element in returned S-expression\n");
2200
2201   gcry_sexp_release (s_sig);
2202   s_sig = s_tmp;
2203
2204   s_tmp = gcry_sexp_find_token (s_sig, "r", 0);
2205   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
2206   if (!tmpmpi)
2207     die ("no r parameter in returned S-expression\n");
2208   print_mpi_line (tmpmpi, 1);
2209   gcry_mpi_release (tmpmpi);
2210   gcry_sexp_release (s_tmp);
2211
2212   s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
2213   tmpmpi = gcry_sexp_nth_mpi (s_tmp, 1, GCRYMPI_FMT_USG);
2214   if (!tmpmpi)
2215     die ("no s parameter in returned S-expression\n");
2216   print_mpi_line (tmpmpi, 1);
2217   gcry_mpi_release (tmpmpi);
2218   gcry_sexp_release (s_tmp);
2219
2220   gcry_sexp_release (s_sig);
2221 }
2222
2223
2224 \f
2225 /* Verify DATA of length DATALEN using the public key taken from the
2226    S-expression in KEYFILE against the S-expression formatted
2227    signature in SIGFILE.  */
2228 static void
2229 run_ecdsa_verify (const void *data, size_t datalen,
2230                 const char *keyfile, const int algo, const char *sigfile)
2231
2232 {
2233   gpg_error_t err;
2234   gcry_sexp_t s_data, s_key, s_sig;
2235   char hash[128];
2236   gcry_mpi_t tmpmpi;
2237
2238   s_key = read_sexp_from_file (keyfile);
2239
2240   gcry_md_hash_buffer (algo, hash, data, datalen);
2241   /* Note that we can't simply use %b with HASH to build the
2242      S-expression, because that might yield a negative value.  */
2243   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash,
2244                        gcry_md_get_algo_dlen(algo), NULL);
2245   if (!err)
2246     {
2247       err = gcry_sexp_build (&s_data, NULL,
2248                              "(data (flags raw)(hash %s %M))",
2249                              gcry_md_algo_name(algo), tmpmpi);
2250       gcry_mpi_release (tmpmpi);
2251     }
2252   if (err)
2253     die ("gcry_sexp_build failed for DSA data input: %s\n",
2254          gpg_strerror (err));
2255
2256   s_sig = read_sexp_from_file (sigfile);
2257
2258   err = gcry_pk_verify (s_sig, s_data, s_key);
2259   if (!err)
2260     puts ("GOOD signature");
2261   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
2262     puts ("BAD signature");
2263   else
2264     printf ("ERROR (%s)\n", gpg_strerror (err));
2265
2266   gcry_sexp_release (s_sig);
2267   gcry_sexp_release (s_key);
2268   gcry_sexp_release (s_data);
2269 }
2270
2271
2272 /* Generate an ECDSA key with specified domain parameters
2273    and print the d and Q values, in the standard octet-string format. */
2274 static void
2275 run_ecdsa_gen_key (const char *curve)
2276 {
2277   gcry_sexp_t key;
2278
2279   key = ecdsa_gen_key (curve);
2280   print_ecdsa_dq (key);
2281
2282   gcry_sexp_release (key);
2283 }
2284
2285
2286 \f
2287 static void
2288 usage (int show_help)
2289 {
2290   if (!show_help)
2291     {
2292       fputs ("usage: " PGM
2293              " [OPTION] [FILE] (try --help for more information)\n", stderr);
2294       exit (2);
2295     }
2296   fputs
2297     ("Usage: " PGM " [OPTIONS] MODE [FILE]\n"
2298      "Run a crypto operation using hex encoded input and output.\n"
2299      "MODE:\n"
2300      "  encrypt, decrypt, digest, random, hmac-sha,\n"
2301      "  rsa-{derive,gen,sign,verify},\n"
2302      "  dsa-{pqg-gen,gen,sign,verify}, ecdsa-{gen-key,sign,verify}\n"
2303      "OPTIONS:\n"
2304      "  --verbose        Print additional information\n"
2305      "  --binary         Input and output is in binary form\n"
2306      "  --no-fips        Do not force FIPS mode\n"
2307      "  --key KEY        Use the hex encoded KEY\n"
2308      "  --iv IV          Use the hex encoded IV\n"
2309      "  --dt DT          Use the hex encoded DT for the RNG\n"
2310      "  --algo NAME      Use algorithm NAME\n"
2311      "  --curve NAME     Select ECC curve spec NAME\n"
2312      "  --keysize N      Use a keysize of N bits\n"
2313      "  --signature NAME Take signature from file NAME\n"
2314      "  --chunk N        Read in chunks of N bytes (implies --binary)\n"
2315      "  --pkcs1          Use PKCS#1 encoding\n"
2316      "  --pss            Use PSS encoding with a zero length salt\n"
2317      "  --mct-server     Run a monte carlo test server\n"
2318      "  --loop           Enable random loop mode\n"
2319      "  --progress       Print pogress indicators\n"
2320      "  --help           Print this text\n"
2321      "With no FILE, or when FILE is -, read standard input.\n"
2322      "Report bugs to " PACKAGE_BUGREPORT ".\n" , stdout);
2323   exit (0);
2324 }
2325
2326 int
2327 main (int argc, char **argv)
2328 {
2329   int last_argc = -1;
2330   gpg_error_t err;
2331   int no_fips = 0;
2332   int progress = 0;
2333   int use_pkcs1 = 0;
2334   int use_pss = 0;
2335   const char *mode_string;
2336   const char *curve_string = NULL;
2337   const char *key_string = NULL;
2338   const char *iv_string = NULL;
2339   const char *dt_string = NULL;
2340   const char *algo_string = NULL;
2341   const char *keysize_string = NULL;
2342   const char *signature_string = NULL;
2343   FILE *input;
2344   void *data;
2345   size_t datalen;
2346   size_t chunksize = 0;
2347   int mct_server = 0;
2348
2349
2350   if (argc)
2351     { argc--; argv++; }
2352
2353   while (argc && last_argc != argc )
2354     {
2355       last_argc = argc;
2356       if (!strcmp (*argv, "--"))
2357         {
2358           argc--; argv++;
2359           break;
2360         }
2361       else if (!strcmp (*argv, "--help"))
2362         {
2363           usage (1);
2364         }
2365       else if (!strcmp (*argv, "--version"))
2366         {
2367           fputs (PGM " (Libgcrypt) " PACKAGE_VERSION "\n", stdout);
2368           exit (0);
2369         }
2370       else if (!strcmp (*argv, "--verbose"))
2371         {
2372           verbose++;
2373           argc--; argv++;
2374         }
2375       else if (!strcmp (*argv, "--binary"))
2376         {
2377           binary_input = binary_output = 1;
2378           argc--; argv++;
2379         }
2380       else if (!strcmp (*argv, "--no-fips"))
2381         {
2382           no_fips++;
2383           argc--; argv++;
2384         }
2385       else if (!strcmp (*argv, "--loop"))
2386         {
2387           loop_mode = 1;
2388           argc--; argv++;
2389         }
2390       else if (!strcmp (*argv, "--progress"))
2391         {
2392           progress = 1;
2393           argc--; argv++;
2394         }
2395       else if (!strcmp (*argv, "--key"))
2396         {
2397           argc--; argv++;
2398           if (!argc)
2399             usage (0);
2400           key_string = *argv;
2401           argc--; argv++;
2402         }
2403       else if (!strcmp (*argv, "--iv"))
2404         {
2405           argc--; argv++;
2406           if (!argc)
2407             usage (0);
2408           iv_string = *argv;
2409           argc--; argv++;
2410         }
2411       else if (!strcmp (*argv, "--dt"))
2412         {
2413           argc--; argv++;
2414           if (!argc)
2415             usage (0);
2416           dt_string = *argv;
2417           argc--; argv++;
2418         }
2419       else if (!strcmp (*argv, "--algo"))
2420         {
2421           argc--; argv++;
2422           if (!argc)
2423             usage (0);
2424           algo_string = *argv;
2425           argc--; argv++;
2426         }
2427       else if (!strcmp (*argv, "--keysize"))
2428         {
2429           argc--; argv++;
2430           if (!argc)
2431             usage (0);
2432           keysize_string = *argv;
2433           argc--; argv++;
2434         }
2435       else if (!strcmp (*argv, "--signature"))
2436         {
2437           argc--; argv++;
2438           if (!argc)
2439             usage (0);
2440           signature_string = *argv;
2441           argc--; argv++;
2442         }
2443       else if (!strcmp (*argv, "--chunk"))
2444         {
2445           argc--; argv++;
2446           if (!argc)
2447             usage (0);
2448           chunksize = atoi (*argv);
2449           binary_input = binary_output = 1;
2450           argc--; argv++;
2451         }
2452       else if (!strcmp (*argv, "--curve"))
2453         {
2454           argc--; argv++;
2455           if (!argc)
2456             usage (0);
2457           curve_string = *argv;
2458           argc--; argv++;
2459         }
2460       else if (!strcmp (*argv, "--pkcs1"))
2461         {
2462           use_pkcs1 = 1;
2463           argc--; argv++;
2464         }
2465       else if (!strcmp (*argv, "--pss"))
2466         {
2467           use_pss = 1;
2468           argc--; argv++;
2469         }
2470       else if (!strcmp (*argv, "--mct-server"))
2471         {
2472           mct_server = 1;
2473           argc--; argv++;
2474         }
2475       else if (!strcmp (*argv, "--standalone"))
2476         {
2477           standalone_mode = 1;
2478           argc--; argv++;
2479         }
2480     }
2481
2482   if (!argc || argc > 2)
2483     usage (0);
2484
2485   mode_string = *argv;
2486
2487   if (use_pkcs1 && use_pss)
2488     die ("Only one of --pkcs or --pss may be given\n");
2489
2490   if (!strcmp (mode_string, "rsa-derive"))
2491     binary_input = 1;
2492
2493   if (argc == 2 && strcmp (argv[1], "-"))
2494     {
2495       input = fopen (argv[1], binary_input? "rb":"r");
2496       if (!input)
2497         die ("can't open `%s': %s\n", argv[1], strerror (errno));
2498     }
2499   else
2500     input = stdin;
2501
2502 #ifndef HAVE_W32_SYSTEM
2503   if (loop_mode)
2504     signal (SIGPIPE, SIG_IGN);
2505 #endif
2506
2507   if (verbose)
2508     fprintf (stderr, PGM ": started (mode=%s)\n", mode_string);
2509
2510   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
2511   if (!no_fips)
2512     gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
2513   if (!gcry_check_version ("1.4.3"))
2514     die ("Libgcrypt is not sufficient enough\n");
2515   if (verbose)
2516     fprintf (stderr, PGM ": using Libgcrypt %s\n", gcry_check_version (NULL));
2517   if (no_fips)
2518     gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
2519   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
2520
2521   /* Most operations need some input data.  */
2522   if (!chunksize
2523       && !mct_server
2524       && strcmp (mode_string, "random")
2525       && strcmp (mode_string, "rsa-gen")
2526       && strcmp (mode_string, "rsa-keygen")
2527       && strcmp (mode_string, "rsa-keygen-kat")
2528       && strcmp (mode_string, "dsa-gen")
2529       && strcmp (mode_string, "ecdsa-gen-key") )
2530     {
2531       data = read_file (input, !binary_input, &datalen);
2532       if (!data)
2533         die ("error reading%s input\n", binary_input?"":" and decoding");
2534       if (verbose)
2535         fprintf (stderr, PGM ": %u bytes of input data\n",
2536                  (unsigned int)datalen);
2537     }
2538   else
2539     {
2540       data = NULL;
2541       datalen = 0;
2542     }
2543
2544
2545   if (!strcmp (mode_string, "encrypt") || !strcmp (mode_string, "decrypt"))
2546     {
2547       int cipher_algo, cipher_mode;
2548       void  *iv_buffer = NULL;
2549       void *key_buffer = NULL;
2550       size_t iv_buflen,  key_buflen;
2551
2552       if (!algo_string)
2553         die ("option --algo is required in this mode\n");
2554       cipher_algo = map_openssl_cipher_name (algo_string, &cipher_mode);
2555       if (!cipher_algo)
2556         die ("cipher algorithm `%s' is not supported\n", algo_string);
2557       if (mct_server)
2558         {
2559           int iterations;
2560
2561           for (;;)
2562             {
2563               gcry_free (key_buffer); key_buffer = NULL;
2564               gcry_free (iv_buffer); iv_buffer = NULL;
2565               gcry_free (data); data = NULL;
2566               if (!(key_buffer = read_textline (input)))
2567                 {
2568                   if (feof (input))
2569                     break;
2570                   die ("no version info in input\n");
2571                 }
2572               if (atoi (key_buffer) != 1)
2573                 die ("unsupported input version %s\n", key_buffer);
2574               gcry_free (key_buffer);
2575               if (!(key_buffer = read_textline (input)))
2576                 die ("no iteration count in input\n");
2577               iterations = atoi (key_buffer);
2578               gcry_free (key_buffer);
2579               if (!(key_buffer = read_hexline (input, &key_buflen)))
2580                 die ("no key in input\n");
2581               if (!(iv_buffer = read_hexline (input, &iv_buflen)))
2582                 die ("no IV in input\n");
2583               if (!(data = read_hexline (input, &datalen)))
2584                 die ("no data in input\n");
2585               skip_to_empty_line (input);
2586
2587               run_cipher_mct_loop ((*mode_string == 'e'),
2588                                    cipher_algo, cipher_mode,
2589                                    iv_buffer, iv_buflen,
2590                                    key_buffer, key_buflen,
2591                                    data, datalen, iterations);
2592             }
2593         }
2594       else
2595         {
2596           if (cipher_mode != GCRY_CIPHER_MODE_ECB)
2597             {
2598               if (!iv_string)
2599                 die ("option --iv is required in this mode\n");
2600               iv_buffer = hex2buffer (iv_string, &iv_buflen);
2601               if (!iv_buffer)
2602                 die ("invalid value for IV\n");
2603             }
2604           else
2605             {
2606               iv_buffer = NULL;
2607               iv_buflen = 0;
2608             }
2609           if (!key_string)
2610             die ("option --key is required in this mode\n");
2611           key_buffer = hex2buffer (key_string, &key_buflen);
2612           if (!key_buffer)
2613             die ("invalid value for KEY\n");
2614
2615           run_encrypt_decrypt ((*mode_string == 'e'),
2616                                cipher_algo, cipher_mode,
2617                                iv_buffer, iv_buflen,
2618                                key_buffer, key_buflen,
2619                                data, data? datalen:chunksize, input);
2620         }
2621       gcry_free (key_buffer);
2622       gcry_free (iv_buffer);
2623     }
2624   else if (!strcmp (mode_string, "digest"))
2625     {
2626       int algo;
2627
2628       if (!algo_string)
2629         die ("option --algo is required in this mode\n");
2630       algo = gcry_md_map_name (algo_string);
2631       if (!algo)
2632         die ("digest algorithm `%s' is not supported\n", algo_string);
2633       if (!data)
2634         die ("no data available (do not use --chunk)\n");
2635
2636       run_digest (algo, data, datalen);
2637     }
2638   else if (!strcmp (mode_string, "random"))
2639     {
2640       void *context;
2641       unsigned char key[16];
2642       unsigned char seed[16];
2643       unsigned char dt[16];
2644       unsigned char buffer[16];
2645       size_t count = 0;
2646
2647       if (hex2bin (key_string, key, 16) < 0 )
2648         die ("value for --key are not 32 hex digits\n");
2649       if (hex2bin (iv_string, seed, 16) < 0 )
2650         die ("value for --iv are not 32 hex digits\n");
2651       if (hex2bin (dt_string, dt, 16) < 0 )
2652         die ("value for --dt are not 32 hex digits\n");
2653
2654       /* The flag value 1 disables the dup check, so that the RNG
2655          returns all generated data.  */
2656       err = init_external_rng_test (&context, 1, key, 16, seed, 16, dt, 16);
2657       if (err)
2658         die ("init external RNG test failed: %s\n", gpg_strerror (err));
2659
2660       do
2661         {
2662           err = run_external_rng_test (context, buffer, sizeof buffer);
2663           if (err)
2664             die ("running external RNG test failed: %s\n", gpg_strerror (err));
2665           print_buffer (buffer, sizeof buffer);
2666           if (progress)
2667             {
2668               if (!(++count % 1000))
2669                 fprintf (stderr, PGM ": %lu random bytes so far\n",
2670                          (unsigned long int)(count * sizeof buffer));
2671             }
2672         }
2673       while (loop_mode);
2674
2675       if (progress)
2676         fprintf (stderr, PGM ": %lu random bytes\n",
2677                  (unsigned long int)(count * sizeof buffer));
2678
2679       deinit_external_rng_test (context);
2680     }
2681   else if (!strcmp (mode_string, "hmac-sha"))
2682     {
2683       int algo;
2684       void  *key_buffer;
2685       size_t key_buflen;
2686
2687       if (!data)
2688         die ("no data available (do not use --chunk)\n");
2689       if (!algo_string)
2690         die ("option --algo is required in this mode\n");
2691       switch (atoi (algo_string))
2692         {
2693         case 1:   algo = GCRY_MD_SHA1; break;
2694         case 224: algo = GCRY_MD_SHA224; break;
2695         case 256: algo = GCRY_MD_SHA256; break;
2696         case 384: algo = GCRY_MD_SHA384; break;
2697         case 512: algo = GCRY_MD_SHA512; break;
2698         default:  algo = 0; break;
2699         }
2700       if (!algo)
2701         die ("no digest algorithm found for hmac type `%s'\n", algo_string);
2702       if (!key_string)
2703         die ("option --key is required in this mode\n");
2704       key_buffer = hex2buffer (key_string, &key_buflen);
2705       if (!key_buffer)
2706         die ("invalid value for KEY\n");
2707
2708       run_hmac (algo, key_buffer, key_buflen, data, datalen);
2709
2710       gcry_free (key_buffer);
2711     }
2712   else if (!strcmp (mode_string, "rsa-derive"))
2713     {
2714       if (!data)
2715         die ("no data available (do not use --chunk)\n");
2716       run_rsa_derive (data, datalen);
2717     }
2718   else if (!strcmp (mode_string, "rsa-keygen"))
2719     {
2720       data = read_file (input, 0, &datalen);
2721       if (!data)
2722         die ("no data available (do not use --chunk)\n");
2723       run_rsa_keygen (data, datalen, 0);
2724     }
2725   else if (!strcmp (mode_string, "rsa-keygen-kat"))
2726     {
2727       data = read_file (input, 0, &datalen);
2728       if (!data)
2729         die ("no data available (do not use --chunk)\n");
2730       run_rsa_keygen (data, datalen, 1);
2731     }
2732   else if (!strcmp (mode_string, "rsa-gen"))
2733     {
2734       int keysize;
2735
2736       if (!binary_output)
2737         base64_output = 1;
2738
2739       keysize = keysize_string? atoi (keysize_string) : 0;
2740       if (keysize < 128 || keysize > 16384)
2741         die ("invalid keysize specified; needs to be 128 .. 16384\n");
2742       run_rsa_gen (keysize, 65537);
2743     }
2744   else if (!strcmp (mode_string, "rsa-sign"))
2745     {
2746       int algo;
2747
2748       if (!key_string)
2749         die ("option --key is required in this mode\n");
2750       if (access (key_string, R_OK))
2751         die ("option --key needs to specify an existing keyfile\n");
2752       if (!algo_string)
2753         die ("option --algo is required in this mode\n");
2754       algo = gcry_md_map_name (algo_string);
2755       if (!algo)
2756         die ("digest algorithm `%s' is not supported\n", algo_string);
2757       if (!data)
2758         die ("no data available (do not use --chunk)\n");
2759
2760       run_rsa_sign (data, datalen, algo, use_pkcs1, use_pss, key_string);
2761
2762     }
2763   else if (!strcmp (mode_string, "rsa-verify"))
2764     {
2765       int algo;
2766
2767       if (!key_string)
2768         die ("option --key is required in this mode\n");
2769       if (access (key_string, R_OK))
2770         die ("option --key needs to specify an existing keyfile\n");
2771       if (!algo_string)
2772         die ("option --algo is required in this mode\n");
2773       algo = gcry_md_map_name (algo_string);
2774       if (!algo)
2775         die ("digest algorithm `%s' is not supported\n", algo_string);
2776       if (!data)
2777         die ("no data available (do not use --chunk)\n");
2778       if (!signature_string)
2779         die ("option --signature is required in this mode\n");
2780       if (access (signature_string, R_OK))
2781         die ("option --signature needs to specify an existing file\n");
2782
2783       run_rsa_verify (data, datalen, algo, use_pkcs1, use_pss, key_string,
2784                       signature_string);
2785
2786     }
2787   else if (!strcmp (mode_string, "dsa-pqg-gen"))
2788     {
2789       int keysize;
2790
2791       keysize = keysize_string? atoi (keysize_string) : 0;
2792       if (keysize < 1024 || keysize > 3072)
2793         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
2794       run_dsa_pqg_gen (keysize, datalen? data:NULL, datalen);
2795     }
2796   else if (!strcmp (mode_string, "dsa-gen"))
2797     {
2798       int keysize;
2799
2800       keysize = keysize_string? atoi (keysize_string) : 0;
2801       if (keysize < 1024 || keysize > 3072)
2802         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
2803       if (!key_string)
2804         die ("option --key is required in this mode\n");
2805       run_dsa_gen (keysize, key_string);
2806     }
2807   else if (!strcmp (mode_string, "dsa-sign"))
2808     {
2809       if (!key_string)
2810         die ("option --key is required in this mode\n");
2811       if (access (key_string, R_OK))
2812         die ("option --key needs to specify an existing keyfile\n");
2813       if (!data)
2814         die ("no data available (do not use --chunk)\n");
2815
2816       run_dsa_sign (data, datalen, key_string);
2817     }
2818   else if (!strcmp (mode_string, "dsa-verify"))
2819     {
2820       if (!key_string)
2821         die ("option --key is required in this mode\n");
2822       if (access (key_string, R_OK))
2823         die ("option --key needs to specify an existing keyfile\n");
2824       if (!data)
2825         die ("no data available (do not use --chunk)\n");
2826       if (!signature_string)
2827         die ("option --signature is required in this mode\n");
2828       if (access (signature_string, R_OK))
2829         die ("option --signature needs to specify an existing file\n");
2830
2831       run_dsa_verify (data, datalen, key_string, signature_string);
2832     }
2833   else if (!strcmp (mode_string, "ecdsa-gen-key"))
2834     {
2835       if (!curve_string)
2836         die ("option --curve containing name of the specified curve is required in this mode\n");
2837       run_ecdsa_gen_key (curve_string);
2838     }
2839   else if (!strcmp (mode_string, "ecdsa-sign"))
2840     {
2841       int algo;
2842
2843       if (!key_string)
2844         die ("option --key is required in this mode\n");
2845       if (access (key_string, R_OK))
2846         die ("option --key needs to specify an existing keyfile\n");
2847       if (!algo_string)
2848         die ("use --algo to specify the digest algorithm\n");
2849       algo = gcry_md_map_name (algo_string);
2850       if (!algo)
2851         die ("digest algorithm `%s' is not supported\n", algo_string);
2852
2853       if (!data)
2854         die ("no data available (do not use --chunk)\n");
2855
2856       run_ecdsa_sign (data, datalen, key_string, algo);
2857     }
2858   else if (!strcmp (mode_string, "ecdsa-verify"))
2859     {
2860       int algo;
2861
2862       if (!key_string)
2863         die ("option --key is required in this mode\n");
2864       if (access (key_string, R_OK))
2865         die ("option --key needs to specify an existing keyfile\n");
2866       if (!algo_string)
2867         die ("use --algo to specify the digest algorithm\n");
2868       algo = gcry_md_map_name (algo_string);
2869       if (!algo)
2870         die ("digest algorithm `%s' is not supported\n", algo_string);
2871       if (!data)
2872         die ("no data available (do not use --chunk)\n");
2873       if (!signature_string)
2874         die ("option --signature is required in this mode\n");
2875       if (access (signature_string, R_OK))
2876         die ("option --signature needs to specify an existing file\n");
2877
2878       run_ecdsa_verify (data, datalen, key_string, algo, signature_string);
2879     }
2880   else
2881     usage (0);
2882
2883   gcry_free (data);
2884
2885   /* Because Libgcrypt does not enforce FIPS mode in all cases we let
2886      the process die if Libgcrypt is not anymore in FIPS mode after
2887      the actual operation.  */
2888   if (!no_fips && !gcry_fips_mode_active ())
2889     die ("FIPS mode is not anymore active\n");
2890
2891   if (verbose)
2892     fputs (PGM ": ready\n", stderr);
2893
2894   return 0;
2895 }