Added common certificates.
[gnupg.git] / sm / certreqgen.c
1 /* certreqgen.c - Generate a key and a certification request
2  *      Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG 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 General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 /*
23 The format of the native parameter file is follows:
24   o Text only, line length is limited to about 1000 chars.
25   o You must use UTF-8 encoding to specify non-ascii characters.
26   o Empty lines are ignored.
27   o Leading and trailing spaces are ignored.
28   o A hash sign as the first non white space character is a comment line.
29   o Control statements are indicated by a leading percent sign, the
30     arguments are separated by white space from the keyword.
31   o Parameters are specified by a keyword, followed by a colon.  Arguments
32     are separated by white space.
33   o The first parameter must be "Key-Type", control statements
34     may be placed anywhere.
35   o Key generation takes place when either the end of the parameter file
36     is reached, the next "Key-Type" parameter is encountered or at the
37     controlstatement "%commit"
38   o Control statements:
39     %echo <text>
40         Print <text>.
41     %dry-run
42         Suppress actual key generation (useful for syntax checking).
43     %commit
44         Perform the key generation.  Note that an implicit commit is done
45         at the next "Key-Type" parameter.
46     %certfile <filename>
47         Do not write the certificate to the keyDB but to <filename>.
48         This must be given before the first
49         commit to take place, duplicate specification of the same filename
50         is ignored, the last filename before a commit is used.
51         The filename is used until a new filename is used (at commit points)
52         and all keys are written to that file.  If a new filename is given,
53         this file is created (and overwrites an existing one).
54         Both control statements must be given.
55    o The order of the parameters does not matter except for "Key-Type"
56      which must be the first parameter.  The parameters are only for the
57      generated keyblock and parameters from previous key generations are not
58      used. Some syntactically checks may be performed.
59      The currently defined parameters are:
60      Key-Type: <algo>
61         Starts a new parameter block by giving the type of the
62         primary key. The algorithm must be capable of signing.
63         This is a required parameter.  For now the only supported
64         algorithm is "rsa".
65      Key-Length: <length-in-bits>
66         Length of the key in bits.  Default is 1024.
67      Key-Grip: hexstring
68         This is optional and used to generate a request for an already
69         existing key.  Key-Length will be ignored when given,
70      Key-Usage: <usage-list>
71         Space or comma delimited list of key usage, allowed values are
72         "encrypt" and "sign".  This is used to generate the KeyUsage extension.
73         Please make sure that the algorithm is capable of this usage.  Default
74         is to allow encrypt and sign.
75      Name-DN: subject name
76         This is the DN name of the subject in rfc2253 format.
77      Name-Email: <string>
78         The is an email address for the altSubjectName
79      Name-DNS: <string> 
80         The is an DNS name for the altSubjectName
81      Name-URI: <string> 
82         The is an URI for the altSubjectName
83
84 Here is an example:
85 $ cat >foo <<EOF
86 %echo Generating a standard key
87 Key-Type: RSA
88 Key-Length: 1024
89 Name-DN: CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=Düsseldorf,C=DE
90 Name-Email: joe@foo.bar
91 # Do a commit here, so that we can later print "done" :-)
92 %commit
93 %echo done
94 EOF
95 */
96
97
98 #include <config.h>
99 #include <stdio.h>
100 #include <stdlib.h>
101 #include <string.h>
102 #include <errno.h>
103 #include <unistd.h> 
104 #include <time.h>
105 #include <assert.h>
106
107 #include "gpgsm.h"
108 #include <gcrypt.h>
109 #include <ksba.h>
110
111 #include "keydb.h"
112 #include "i18n.h"
113
114
115 enum para_name {
116   pKEYTYPE,
117   pKEYLENGTH,
118   pKEYGRIP,
119   pKEYUSAGE,
120   pNAMEDN,
121   pNAMEEMAIL,
122   pNAMEDNS,
123   pNAMEURI
124 };
125
126 struct para_data_s {
127   struct para_data_s *next;
128   int lnr;
129   enum para_name key;
130   union {
131     unsigned int usage; 
132     char value[1];
133   } u;
134 };
135
136 struct reqgen_ctrl_s {
137   int lnr;
138   int dryrun;
139   ksba_writer_t writer;
140 };
141
142
143 static const char oidstr_keyUsage[] = "2.5.29.15";
144
145
146 static int proc_parameters (ctrl_t ctrl,
147                             struct para_data_s *para,
148                             struct reqgen_ctrl_s *outctrl);
149 static int create_request (ctrl_t ctrl,
150                            struct para_data_s *para,
151                            ksba_const_sexp_t public,
152                            struct reqgen_ctrl_s *outctrl);
153
154
155 \f
156 static void
157 release_parameter_list (struct para_data_s *r)
158 {
159   struct para_data_s *r2;
160   
161   for (; r ; r = r2)
162     {
163       r2 = r->next;
164       xfree(r);
165     }
166 }
167
168 static struct para_data_s *
169 get_parameter (struct para_data_s *para, enum para_name key, int seq)
170 {
171   struct para_data_s *r;
172   
173   for (r = para; r ; r = r->next)
174     if ( r->key == key && !seq--)
175       return r;
176   return NULL;
177 }
178
179 static const char *
180 get_parameter_value (struct para_data_s *para, enum para_name key, int seq)
181 {
182   struct para_data_s *r = get_parameter (para, key, seq);
183   return (r && *r->u.value)? r->u.value : NULL;
184 }
185
186 static int
187 get_parameter_algo (struct para_data_s *para, enum para_name key)
188 {
189   struct para_data_s *r = get_parameter (para, key, 0);
190   if (!r)
191     return -1;
192   if (digitp (r->u.value))
193     return atoi( r->u.value );
194   return gcry_pk_map_name (r->u.value); 
195 }
196
197 /* Parse the usage parameter.  Returns 0 on success.  Note that we
198    only care about sign and encrypt and don't (yet) allow all the
199    other X.509 usage to be specified; instead we will use a fixed
200    mapping to the X.509 usage flags. */
201 static int
202 parse_parameter_usage (struct para_data_s *para, enum para_name key)
203 {
204   struct para_data_s *r = get_parameter (para, key, 0);
205   char *p, *pn;
206   unsigned int use;
207   
208   if (!r)
209     return 0; /* none (this is an optional parameter)*/
210     
211   use = 0;
212   pn = r->u.value;
213   while ( (p = strsep (&pn, " \t,")) )
214     {
215       if (!*p)
216         ;
217       else if ( !ascii_strcasecmp (p, "sign") )
218         use |= GCRY_PK_USAGE_SIGN;
219       else if ( !ascii_strcasecmp (p, "encrypt") )
220         use |= GCRY_PK_USAGE_ENCR;
221       else
222         {
223           log_error ("line %d: invalid usage list\n", r->lnr);
224           return -1; /* error */
225         }
226     }
227   r->u.usage = use;
228   return 0;
229 }
230
231
232 static unsigned int
233 get_parameter_uint (struct para_data_s *para, enum para_name key)
234 {
235   struct para_data_s *r = get_parameter (para, key, 0);
236
237   if (!r)
238     return 0;
239
240   if (r->key == pKEYUSAGE)
241     return r->u.usage;
242
243   return (unsigned int)strtoul (r->u.value, NULL, 10);
244 }
245
246
247
248 /* Read the certificate generation parameters from FP and generate
249    (all) certificate requests.  */
250 static int
251 read_parameters (ctrl_t ctrl, FILE *fp, ksba_writer_t writer)
252 {
253   static struct {
254     const char *name;
255     enum para_name key;
256     int allow_dups;
257   } keywords[] = {
258     { "Key-Type",       pKEYTYPE},
259     { "Key-Length",     pKEYLENGTH },
260     { "Key-Grip",       pKEYGRIP },
261     { "Key-Usage",      pKEYUSAGE },
262     { "Name-DN",        pNAMEDN },
263     { "Name-Email",     pNAMEEMAIL, 1 },
264     { "Name-DNS",       pNAMEDNS, 1 },
265     { "Name-URI",       pNAMEURI, 1 },
266     { NULL, 0 }
267   };
268   char line[1024], *p;
269   const char *err = NULL;
270   struct para_data_s *para, *r;
271   int i, rc = 0, any = 0;
272   struct reqgen_ctrl_s outctrl;
273
274   memset (&outctrl, 0, sizeof (outctrl));
275   outctrl.writer = writer;
276
277   err = NULL;
278   para = NULL;
279   while (fgets (line, DIM(line)-1, fp) )
280     {
281       char *keyword, *value;
282
283       outctrl.lnr++;
284       if (*line && line[strlen(line)-1] != '\n')
285         {
286           err = "line too long";
287           break;
288         }
289       for (p=line; spacep (p); p++)
290         ;
291       if (!*p || *p == '#')
292         continue;
293
294       keyword = p;
295       if (*keyword == '%')
296         {
297           for (; *p && !spacep (p); p++)
298             ;
299           if (*p)
300             *p++ = 0;
301           for (; spacep (p); p++)
302             ;
303           value = p;
304           trim_trailing_spaces (value);
305
306           if (!ascii_strcasecmp (keyword, "%echo"))
307             log_info ("%s\n", value);
308           else if (!ascii_strcasecmp (keyword, "%dry-run"))
309             outctrl.dryrun = 1;
310           else if (!ascii_strcasecmp( keyword, "%commit"))
311             {
312               rc = proc_parameters (ctrl, para, &outctrl);
313               if (rc)
314                 goto leave;
315               any = 1;
316               release_parameter_list (para);
317               para = NULL;
318             }
319           else
320             log_info ("skipping control `%s' (%s)\n", keyword, value);
321
322           continue;
323         }
324
325
326       if (!(p = strchr (p, ':')) || p == keyword)
327         {
328           err = "missing colon";
329           break;
330         }
331       if (*p)
332         *p++ = 0;
333       for (; spacep (p); p++)
334         ;
335       if (!*p)
336         {
337           err = "missing argument";
338           break;
339         }
340       value = p;
341       trim_trailing_spaces (value);
342
343       for (i=0; (keywords[i].name
344                  && ascii_strcasecmp (keywords[i].name, keyword)); i++)
345         ;
346       if (!keywords[i].name)
347         {
348           err = "unknown keyword";
349           break;
350         }
351       if (keywords[i].key != pKEYTYPE && !para)
352         {
353           err = "parameter block does not start with \"Key-Type\"";
354           break;
355         }
356
357       if (keywords[i].key == pKEYTYPE && para)
358         {
359           rc = proc_parameters (ctrl, para, &outctrl);
360           if (rc)
361             goto leave;
362           any = 1;
363           release_parameter_list (para);
364           para = NULL;
365         }
366       else if (!keywords[i].allow_dups)
367         {
368           for (r = para; r && r->key != keywords[i].key; r = r->next)
369             ;
370           if (r)
371             {
372               err = "duplicate keyword";
373               break;
374             }
375         }
376
377       r = xtrycalloc (1, sizeof *r + strlen( value ));
378       if (!r)
379         {
380           err = "out of core";
381           break;
382         }
383       r->lnr = outctrl.lnr;
384       r->key = keywords[i].key;
385       strcpy (r->u.value, value);
386       r->next = para;
387       para = r;
388     }
389
390   if (err)
391     {
392       log_error ("line %d: %s\n", outctrl.lnr, err);
393       rc = gpg_error (GPG_ERR_GENERAL);
394     }
395   else if (ferror(fp))
396     {
397       log_error ("line %d: read error: %s\n", outctrl.lnr, strerror(errno) );
398       rc = gpg_error (GPG_ERR_GENERAL);
399     }
400   else if (para)
401     {
402       rc = proc_parameters (ctrl, para, &outctrl);
403       if (rc)
404         goto leave;
405       any = 1;
406     }
407
408   if (!rc && !any)
409     rc = gpg_error (GPG_ERR_NO_DATA);
410
411  leave:
412   release_parameter_list (para);
413   return rc;
414 }
415
416 /* check whether there are invalid characters in the email address S */
417 static int
418 has_invalid_email_chars (const char *s)
419 {
420   int at_seen=0;
421   static char valid_chars[] = "01234567890_-."
422                               "abcdefghijklmnopqrstuvwxyz"
423                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
424   for (; *s; s++)
425     {
426       if (*s & 0x80)
427         return 1;
428       if (*s == '@')
429         at_seen++;
430       else if (!at_seen && !( !!strchr (valid_chars, *s) || *s == '+'))
431         return 1;
432       else if (at_seen && !strchr (valid_chars, *s))
433         return 1;
434     }
435   return at_seen != 1;
436 }
437
438
439 /* Check that all required parameters are given and perform the action */
440 static int
441 proc_parameters (ctrl_t ctrl,
442                  struct para_data_s *para, struct reqgen_ctrl_s *outctrl)
443 {
444   gpg_error_t err;
445   struct para_data_s *r;
446   const char *s;
447   int i;
448   unsigned int nbits;
449   char numbuf[20];
450   unsigned char keyparms[100];
451   int rc;
452   ksba_sexp_t public;
453   int seq;
454   size_t erroff, errlen;
455
456   /* Check that we have all required parameters; */
457   assert (get_parameter (para, pKEYTYPE, 0));
458
459   /* We can only use RSA for now.  There is a with pkcs-10 on how to
460      use ElGamal because it is expected that a PK algorithm can always
461      be used for signing. */
462   i = get_parameter_algo (para, pKEYTYPE);
463   if (i < 1 || i != GCRY_PK_RSA )
464     {
465       r = get_parameter (para, pKEYTYPE, 0);
466       log_error (_("line %d: invalid algorithm\n"), r->lnr);
467       return gpg_error (GPG_ERR_INV_PARAMETER);
468     }
469   
470   /* Check the keylength. */
471   if (!get_parameter (para, pKEYLENGTH, 0))
472     nbits = 1024;
473   else
474     nbits = get_parameter_uint (para, pKEYLENGTH);
475   if (nbits < 1024 || nbits > 4096)
476     {
477       /* The BSI specs dated 2002-11-25 don't allow lengths below 1024. */
478       r = get_parameter (para, pKEYLENGTH, 0);
479       log_error (_("line %d: invalid key length %u (valid are %d to %d)\n"),
480                  r->lnr, nbits, 1024, 4096);
481       return gpg_error (GPG_ERR_INV_PARAMETER);
482     }
483     
484   /* Check the usage. */
485   if (parse_parameter_usage (para, pKEYUSAGE))
486     return gpg_error (GPG_ERR_INV_PARAMETER);
487
488   /* Check that there is a subject name and that this DN fits our
489      requirements. */
490   if (!(s=get_parameter_value (para, pNAMEDN, 0)))
491     {
492       r = get_parameter (para, pNAMEDN, 0);
493       log_error (_("line %d: no subject name given\n"), r->lnr);
494       return gpg_error (GPG_ERR_INV_PARAMETER);
495     }
496   err = ksba_dn_teststr (s, 0, &erroff, &errlen);
497   if (err)
498     {
499       r = get_parameter (para, pNAMEDN, 0);
500       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_NAME)
501         log_error (_("line %d: invalid subject name label `%.*s'\n"),
502                    r->lnr, (int)errlen, s+erroff);
503       else
504         log_error (_("line %d: invalid subject name `%s' at pos %d\n"),
505                    r->lnr, s, erroff);
506
507       return gpg_error (GPG_ERR_INV_PARAMETER);
508     }
509
510   /* Check that the optional email address is okay. */
511   for (seq=0; (s=get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
512     { 
513       if (has_invalid_email_chars (s)
514           || *s == '@'
515           || s[strlen(s)-1] == '@'
516           || s[strlen(s)-1] == '.'
517           || strstr(s, ".."))
518         {
519           r = get_parameter (para, pNAMEEMAIL, seq);
520           log_error (_("line %d: not a valid email address\n"), r->lnr);
521           return gpg_error (GPG_ERR_INV_PARAMETER);
522         }
523     }
524
525   s = get_parameter_value (para, pKEYGRIP, 0);
526   if (s) /* Use existing key.  */
527     {
528       rc = gpgsm_agent_readkey (ctrl, s, &public);
529       if (rc)
530         {
531           r = get_parameter (para, pKEYTYPE, 0);
532           log_error (_("line %d: error getting key by keygrip `%s': %s\n"),
533                      r->lnr, s, gpg_strerror (rc));
534           return rc;
535         }
536     }
537   else /* Generate new key.  */
538     {
539       sprintf (numbuf, "%u", nbits);
540       snprintf ((char*)keyparms, DIM (keyparms)-1, 
541                 "(6:genkey(3:rsa(5:nbits%d:%s)))",
542                 (int)strlen (numbuf), numbuf);
543       rc = gpgsm_agent_genkey (ctrl, keyparms, &public);
544       if (rc)
545         {
546           r = get_parameter (para, pKEYTYPE, 0);
547           log_error (_("line %d: key generation failed: %s\n"),
548                      r->lnr, gpg_strerror (rc));
549           return rc;
550         }
551     }
552
553   rc = create_request (ctrl, para, public, outctrl);
554   xfree (public);
555
556   return rc;
557 }
558
559
560 /* Parameters are checked, the key pair has been created.  Now
561    generate the request and write it out */
562 static int
563 create_request (ctrl_t ctrl,
564                 struct para_data_s *para, ksba_const_sexp_t public,
565                 struct reqgen_ctrl_s *outctrl)
566 {
567   ksba_certreq_t cr;
568   gpg_error_t err;
569   gcry_md_hd_t md;
570   ksba_stop_reason_t stopreason;
571   int rc = 0;
572   const char *s;
573   unsigned int use;
574   int seq;
575   char *buf, *p;
576   size_t len;
577   char numbuf[30];
578
579   err = ksba_certreq_new (&cr);
580   if (err)
581     return err;
582
583   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0);
584   if (rc)
585     {
586       log_error ("md_open failed: %s\n", gpg_strerror (rc));
587       goto leave;
588     }
589   if (DBG_HASHING)
590     gcry_md_start_debug (md, "cr.cri");
591
592   ksba_certreq_set_hash_function (cr, HASH_FNC, md);
593   ksba_certreq_set_writer (cr, outctrl->writer);
594   
595   err = ksba_certreq_add_subject (cr, get_parameter_value (para, pNAMEDN, 0));
596   if (err)
597     {
598       log_error ("error setting the subject's name: %s\n",
599                  gpg_strerror (err));
600       rc = err;
601       goto leave;
602     }
603
604   for (seq=0; (s = get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
605     {
606       buf = xtrymalloc (strlen (s) + 3);
607       if (!buf)
608         {
609           rc = out_of_core ();
610           goto leave;
611         }
612       *buf = '<';
613       strcpy (buf+1, s);
614       strcat (buf+1, ">");
615       err = ksba_certreq_add_subject (cr, buf);
616       xfree (buf);
617       if (err)
618         {
619           log_error ("error setting the subject's alternate name: %s\n",
620                      gpg_strerror (err));
621           rc = err;
622           goto leave;
623         }
624     }
625
626   for (seq=0; (s = get_parameter_value (para, pNAMEDNS, seq)); seq++)
627     {
628       len = strlen (s);
629       assert (len);
630       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
631       buf = p = xtrymalloc (11 + strlen (numbuf) + len + 3);
632       if (!buf)
633         {
634           rc = out_of_core ();
635           goto leave;
636         }
637       p = stpcpy (p, "(8:dns-name");
638       p = stpcpy (p, numbuf);
639       p = stpcpy (p, s);
640       strcpy (p, ")");
641
642       err = ksba_certreq_add_subject (cr, buf);
643       xfree (buf);
644       if (err)
645         {
646           log_error ("error setting the subject's alternate name: %s\n",
647                      gpg_strerror (err));
648           rc = err;
649           goto leave;
650         }
651     }
652
653   for (seq=0; (s = get_parameter_value (para, pNAMEURI, seq)); seq++)
654     {
655       len = strlen (s);
656       assert (len);
657       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
658       buf = p = xtrymalloc (6 + strlen (numbuf) + len + 3);
659       if (!buf)
660         {
661           rc = out_of_core ();
662           goto leave;
663         }
664       p = stpcpy (p, "(3:uri");
665       p = stpcpy (p, numbuf);
666       p = stpcpy (p, s);
667       strcpy (p, ")");
668
669       err = ksba_certreq_add_subject (cr, buf);
670       xfree (buf);
671       if (err)
672         {
673           log_error ("error setting the subject's alternate name: %s\n",
674                      gpg_strerror (err));
675           rc = err;
676           goto leave;
677         }
678     }
679
680
681   err = ksba_certreq_set_public_key (cr, public);
682   if (err)
683     {
684       log_error ("error setting the public key: %s\n",
685                  gpg_strerror (err));
686       rc = err;
687       goto leave;
688     }
689
690   
691   use = get_parameter_uint (para, pKEYUSAGE);
692   if (use == GCRY_PK_USAGE_SIGN)
693     {
694       /* For signing only we encode the bits:
695          KSBA_KEYUSAGE_DIGITAL_SIGNATURE
696          KSBA_KEYUSAGE_NON_REPUDIATION */
697       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1, 
698                                         "\x03\x02\x06\xC0", 4);
699     }
700   else if (use == GCRY_PK_USAGE_ENCR)
701     {
702       /* For encrypt only we encode the bits:
703          KSBA_KEYUSAGE_KEY_ENCIPHERMENT
704          KSBA_KEYUSAGE_DATA_ENCIPHERMENT */
705       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1, 
706                                         "\x03\x02\x04\x30", 4);
707     }
708   else
709     err = 0; /* Both or none given: don't request one. */
710   if (err)
711     {
712       log_error ("error setting the key usage: %s\n",
713                  gpg_strerror (err));
714       rc = err;
715       goto leave;
716     }
717
718                
719   do
720     {
721       err = ksba_certreq_build (cr, &stopreason);
722       if (err)
723         {
724           log_error ("ksba_certreq_build failed: %s\n", gpg_strerror (err));
725           rc = err;
726           goto leave;
727         }
728       if (stopreason == KSBA_SR_NEED_SIG)
729         {
730           gcry_sexp_t s_pkey;
731           size_t n;
732           unsigned char grip[20];
733           char hexgrip[41];
734           unsigned char *sigval;
735           size_t siglen;
736
737           n = gcry_sexp_canon_len (public, 0, NULL, NULL);
738           if (!n)
739             {
740               log_error ("libksba did not return a proper S-Exp\n");
741               err = gpg_error (GPG_ERR_BUG);
742               goto leave;
743             }
744           rc = gcry_sexp_sscan (&s_pkey, NULL, (const char*)public, n);
745           if (rc)
746             {
747               log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
748               goto leave;
749             }
750           if ( !gcry_pk_get_keygrip (s_pkey, grip) )
751             {
752               rc = gpg_error (GPG_ERR_GENERAL);
753               log_error ("can't figure out the keygrip\n");
754               gcry_sexp_release (s_pkey);
755               goto leave;
756             }
757           gcry_sexp_release (s_pkey);
758           for (n=0; n < 20; n++)
759             sprintf (hexgrip+n*2, "%02X", grip[n]);
760
761           rc = gpgsm_agent_pksign (ctrl, hexgrip, NULL,
762                                    gcry_md_read(md, GCRY_MD_SHA1), 
763                                    gcry_md_get_algo_dlen (GCRY_MD_SHA1),
764                                    GCRY_MD_SHA1,
765                                    &sigval, &siglen);
766           if (rc)
767             {
768               log_error ("signing failed: %s\n", gpg_strerror (rc));
769               goto leave;
770             }
771           
772           err = ksba_certreq_set_sig_val (cr, sigval);
773           xfree (sigval);
774           if (err)
775             {
776               log_error ("failed to store the sig_val: %s\n",
777                          gpg_strerror (err));
778               rc = err;
779               goto leave;
780             }
781         }
782     }
783   while (stopreason != KSBA_SR_READY);   
784   
785
786  leave:
787   gcry_md_close (md);
788   ksba_certreq_release (cr);
789   return rc;  
790 }
791
792
793 \f
794 /* Create a new key by reading the parameters from in_fd.  Multiple
795    keys may be created */
796 int
797 gpgsm_genkey (ctrl_t ctrl, int in_fd, FILE *out_fp)
798 {
799   int rc;
800   FILE *in_fp;
801   Base64Context b64writer = NULL;
802   ksba_writer_t writer;
803
804   in_fp = fdopen (dup (in_fd), "rb");
805   if (!in_fp)
806     {
807       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
808       log_error ("fdopen() failed: %s\n", strerror (errno));
809       return tmperr;
810     }
811
812   ctrl->pem_name = "CERTIFICATE REQUEST";
813   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
814   if (rc)
815     {
816       log_error ("can't create writer: %s\n", gpg_strerror (rc));
817       goto leave;
818     }
819
820   rc = read_parameters (ctrl, in_fp, writer);
821   if (rc)
822     {
823       log_error ("error creating certificate request: %s\n",
824                  gpg_strerror (rc));
825       goto leave;
826     }
827
828   rc = gpgsm_finish_writer (b64writer);
829   if (rc) 
830     {
831       log_error ("write failed: %s\n", gpg_strerror (rc));
832       goto leave;
833     }
834
835   gpgsm_status (ctrl, STATUS_KEY_CREATED, "P");
836   log_info ("certificate request created\n");
837
838  leave:
839   gpgsm_destroy_writer (b64writer);
840   fclose (in_fp);
841   return rc;
842 }
843