Moved 1.9 branch to trunk
[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         existsing 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 #if HAVE_KSBA_DN_TESTSTR
497   err = ksba_dn_teststr (s, 0, &erroff, &errlen);
498   if (err)
499     {
500       r = get_parameter (para, pNAMEDN, 0);
501       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_NAME)
502         log_error (_("line %d: invalid subject name label `%.*s'\n"),
503                    r->lnr, (int)errlen, s+erroff);
504       else
505         log_error (_("line %d: invalid subject name `%s' at pos %d\n"),
506                    r->lnr, s, erroff);
507
508       return gpg_error (GPG_ERR_INV_PARAMETER);
509     }
510 #endif /*HAVE_KSBA_DN_TESTSTR*/
511
512   /* Check that the optional email address is okay. */
513   for (seq=0; (s=get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
514     { 
515       if (has_invalid_email_chars (s)
516           || *s == '@'
517           || s[strlen(s)-1] == '@'
518           || s[strlen(s)-1] == '.'
519           || strstr(s, ".."))
520         {
521           r = get_parameter (para, pNAMEEMAIL, seq);
522           log_error (_("line %d: not a valid email address\n"), r->lnr);
523           return gpg_error (GPG_ERR_INV_PARAMETER);
524         }
525     }
526
527   s = get_parameter_value (para, pKEYGRIP, 0);
528   if (s) /* Use existing key.  */
529     {
530       rc = gpgsm_agent_readkey (ctrl, s, &public);
531       if (rc)
532         {
533           r = get_parameter (para, pKEYTYPE, 0);
534           log_error (_("line %d: error getting key by keygrip `%s': %s\n"),
535                      r->lnr, s, gpg_strerror (rc));
536           return rc;
537         }
538     }
539   else /* Generate new key.  */
540     {
541       sprintf (numbuf, "%u", nbits);
542       snprintf ((char*)keyparms, DIM (keyparms)-1, 
543                 "(6:genkey(3:rsa(5:nbits%d:%s)))",
544                 (int)strlen (numbuf), numbuf);
545       rc = gpgsm_agent_genkey (ctrl, keyparms, &public);
546       if (rc)
547         {
548           r = get_parameter (para, pKEYTYPE, 0);
549           log_error (_("line %d: key generation failed: %s\n"),
550                      r->lnr, gpg_strerror (rc));
551           return rc;
552         }
553     }
554
555   rc = create_request (ctrl, para, public, outctrl);
556   xfree (public);
557
558   return rc;
559 }
560
561
562 /* Parameters are checked, the key pair has been created.  Now
563    generate the request and write it out */
564 static int
565 create_request (ctrl_t ctrl,
566                 struct para_data_s *para, ksba_const_sexp_t public,
567                 struct reqgen_ctrl_s *outctrl)
568 {
569   ksba_certreq_t cr;
570   gpg_error_t err;
571   gcry_md_hd_t md;
572   ksba_stop_reason_t stopreason;
573   int rc = 0;
574   const char *s;
575   unsigned int use;
576   int seq;
577   char *buf, *p;
578   size_t len;
579   char numbuf[30];
580
581   err = ksba_certreq_new (&cr);
582   if (err)
583     return err;
584
585   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0);
586   if (rc)
587     {
588       log_error ("md_open failed: %s\n", gpg_strerror (rc));
589       goto leave;
590     }
591   if (DBG_HASHING)
592     gcry_md_start_debug (md, "cr.cri");
593
594   ksba_certreq_set_hash_function (cr, HASH_FNC, md);
595   ksba_certreq_set_writer (cr, outctrl->writer);
596   
597   err = ksba_certreq_add_subject (cr, get_parameter_value (para, pNAMEDN, 0));
598   if (err)
599     {
600       log_error ("error setting the subject's name: %s\n",
601                  gpg_strerror (err));
602       rc = err;
603       goto leave;
604     }
605
606   for (seq=0; (s = get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
607     {
608       buf = xtrymalloc (strlen (s) + 3);
609       if (!buf)
610         {
611           rc = OUT_OF_CORE (errno);
612           goto leave;
613         }
614       *buf = '<';
615       strcpy (buf+1, s);
616       strcat (buf+1, ">");
617       err = ksba_certreq_add_subject (cr, buf);
618       xfree (buf);
619       if (err)
620         {
621           log_error ("error setting the subject's alternate name: %s\n",
622                      gpg_strerror (err));
623           rc = err;
624           goto leave;
625         }
626     }
627
628   for (seq=0; (s = get_parameter_value (para, pNAMEDNS, seq)); seq++)
629     {
630       len = strlen (s);
631       assert (len);
632       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
633       buf = p = xtrymalloc (11 + strlen (numbuf) + len + 3);
634       if (!buf)
635         {
636           rc = OUT_OF_CORE (errno);
637           goto leave;
638         }
639       p = stpcpy (p, "(8:dns-name");
640       p = stpcpy (p, numbuf);
641       p = stpcpy (p, s);
642       strcpy (p, ")");
643
644       err = ksba_certreq_add_subject (cr, buf);
645       xfree (buf);
646       if (err)
647         {
648           log_error ("error setting the subject's alternate name: %s\n",
649                      gpg_strerror (err));
650           rc = err;
651           goto leave;
652         }
653     }
654
655   for (seq=0; (s = get_parameter_value (para, pNAMEURI, seq)); seq++)
656     {
657       len = strlen (s);
658       assert (len);
659       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
660       buf = p = xtrymalloc (6 + strlen (numbuf) + len + 3);
661       if (!buf)
662         {
663           rc = OUT_OF_CORE (errno);
664           goto leave;
665         }
666       p = stpcpy (p, "(3:uri");
667       p = stpcpy (p, numbuf);
668       p = stpcpy (p, s);
669       strcpy (p, ")");
670
671       err = ksba_certreq_add_subject (cr, buf);
672       xfree (buf);
673       if (err)
674         {
675           log_error ("error setting the subject's alternate name: %s\n",
676                      gpg_strerror (err));
677           rc = err;
678           goto leave;
679         }
680     }
681
682
683   err = ksba_certreq_set_public_key (cr, public);
684   if (err)
685     {
686       log_error ("error setting the public key: %s\n",
687                  gpg_strerror (err));
688       rc = err;
689       goto leave;
690     }
691
692   
693   use = get_parameter_uint (para, pKEYUSAGE);
694   if (use == GCRY_PK_USAGE_SIGN)
695     {
696       /* For signing only we encode the bits:
697          KSBA_KEYUSAGE_DIGITAL_SIGNATURE
698          KSBA_KEYUSAGE_NON_REPUDIATION */
699       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1, 
700                                         "\x03\x02\x06\xC0", 4);
701     }
702   else if (use == GCRY_PK_USAGE_ENCR)
703     {
704       /* For encrypt only we encode the bits:
705          KSBA_KEYUSAGE_KEY_ENCIPHERMENT
706          KSBA_KEYUSAGE_DATA_ENCIPHERMENT */
707       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1, 
708                                         "\x03\x02\x04\x30", 4);
709     }
710   else
711     err = 0; /* Both or none given: don't request one. */
712   if (err)
713     {
714       log_error ("error setting the key usage: %s\n",
715                  gpg_strerror (err));
716       rc = err;
717       goto leave;
718     }
719
720                
721   do
722     {
723       err = ksba_certreq_build (cr, &stopreason);
724       if (err)
725         {
726           log_error ("ksba_certreq_build failed: %s\n", gpg_strerror (err));
727           rc = err;
728           goto leave;
729         }
730       if (stopreason == KSBA_SR_NEED_SIG)
731         {
732           gcry_sexp_t s_pkey;
733           size_t n;
734           unsigned char grip[20];
735           char hexgrip[41];
736           unsigned char *sigval;
737           size_t siglen;
738
739           n = gcry_sexp_canon_len (public, 0, NULL, NULL);
740           if (!n)
741             {
742               log_error ("libksba did not return a proper S-Exp\n");
743               err = gpg_error (GPG_ERR_BUG);
744               goto leave;
745             }
746           rc = gcry_sexp_sscan (&s_pkey, NULL, (const char*)public, n);
747           if (rc)
748             {
749               log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
750               goto leave;
751             }
752           if ( !gcry_pk_get_keygrip (s_pkey, grip) )
753             {
754               rc = gpg_error (GPG_ERR_GENERAL);
755               log_error ("can't figure out the keygrip\n");
756               gcry_sexp_release (s_pkey);
757               goto leave;
758             }
759           gcry_sexp_release (s_pkey);
760           for (n=0; n < 20; n++)
761             sprintf (hexgrip+n*2, "%02X", grip[n]);
762
763           rc = gpgsm_agent_pksign (ctrl, hexgrip, NULL,
764                                    gcry_md_read(md, GCRY_MD_SHA1), 
765                                    gcry_md_get_algo_dlen (GCRY_MD_SHA1),
766                                    GCRY_MD_SHA1,
767                                    &sigval, &siglen);
768           if (rc)
769             {
770               log_error ("signing failed: %s\n", gpg_strerror (rc));
771               goto leave;
772             }
773           
774           err = ksba_certreq_set_sig_val (cr, sigval);
775           xfree (sigval);
776           if (err)
777             {
778               log_error ("failed to store the sig_val: %s\n",
779                          gpg_strerror (err));
780               rc = err;
781               goto leave;
782             }
783         }
784     }
785   while (stopreason != KSBA_SR_READY);   
786   
787
788  leave:
789   gcry_md_close (md);
790   ksba_certreq_release (cr);
791   return rc;  
792 }
793
794
795 \f
796 /* Create a new key by reading the parameters from in_fd.  Multiple
797    keys may be created */
798 int
799 gpgsm_genkey (ctrl_t ctrl, int in_fd, FILE *out_fp)
800 {
801   int rc;
802   FILE *in_fp;
803   Base64Context b64writer = NULL;
804   ksba_writer_t writer;
805
806   in_fp = fdopen (dup (in_fd), "rb");
807   if (!in_fp)
808     {
809       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
810       log_error ("fdopen() failed: %s\n", strerror (errno));
811       return tmperr;
812     }
813
814   ctrl->pem_name = "CERTIFICATE REQUEST";
815   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
816   if (rc)
817     {
818       log_error ("can't create writer: %s\n", gpg_strerror (rc));
819       goto leave;
820     }
821
822   rc = read_parameters (ctrl, in_fp, writer);
823   if (rc)
824     {
825       log_error ("error creating certificate request: %s\n",
826                  gpg_strerror (rc));
827       goto leave;
828     }
829
830   rc = gpgsm_finish_writer (b64writer);
831   if (rc) 
832     {
833       log_error ("write failed: %s\n", gpg_strerror (rc));
834       goto leave;
835     }
836
837   gpgsm_status (ctrl, STATUS_KEY_CREATED, "P");
838   log_info ("certificate request created\n");
839
840  leave:
841   gpgsm_destroy_writer (b64writer);
842   fclose (in_fp);
843   return rc;
844 }
845