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