2010-04-23 Marcus Brinkmann <marcus@g10code.de>
[gnupg.git] / sm / certreqgen.c
1 /* certreqgen.c - Generate a key and a certification request
2  * Copyright (C) 2002, 2003, 2005, 2007,
3  *               2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /*
22 The format of the native parameter file is follows:
23   o Text only, line length is limited to about 1000 chars.
24   o You must use UTF-8 encoding to specify non-ascii characters.
25   o Empty lines are ignored.
26   o Leading and trailing spaces are ignored.
27   o A hash sign as the first non white space character is a comment line.
28   o Control statements are indicated by a leading percent sign, the
29     arguments are separated by white space from the keyword.
30   o Parameters are specified by a keyword, followed by a colon.  Arguments
31     are separated by white space.
32   o The first parameter must be "Key-Type", control statements
33     may be placed anywhere.
34   o Key generation takes place when either the end of the parameter file
35     is reached, the next "Key-Type" parameter is encountered or at the
36     controlstatement "%commit"
37   o Control statements:
38     %echo <text>
39         Print <text>.
40     %dry-run
41         Suppress actual key generation (useful for syntax checking).
42     %commit
43         Perform the key generation.  Note that an implicit commit is done
44         at the next "Key-Type" parameter.
45     %certfile <filename>
46         Do not write the certificate to the keyDB but to <filename>.
47         This must be given before the first
48         commit to take place, duplicate specification of the same filename
49         is ignored, the last filename before a commit is used.
50         The filename is used until a new filename is used (at commit points)
51         and all keys are written to that file.  If a new filename is given,
52         this file is created (and overwrites an existing one).
53         Both control statements must be given.
54    o The order of the parameters does not matter except for "Key-Type"
55      which must be the first parameter.  The parameters are only for the
56      generated keyblock and parameters from previous key generations are not
57      used. Some syntactically checks may be performed.
58      The currently defined parameters are:
59      Key-Type: <algo>
60         Starts a new parameter block by giving the type of the
61         primary key. The algorithm must be capable of signing.
62         This is a required parameter.  For now the only supported
63         algorithm is "rsa".
64      Key-Length: <length-in-bits>
65         Length of the key in bits.  Default is 2048.
66      Key-Grip: hexstring
67         This is optional and used to generate a request for an already
68         existing key.  Key-Length will be ignored when given,
69      Key-Usage: <usage-list>
70         Space or comma delimited list of key usage, allowed values are
71         "encrypt" and "sign".  This is used to generate the KeyUsage extension.
72         Please make sure that the algorithm is capable of this usage.  Default
73         is to allow encrypt and sign.
74      Name-DN: subject name
75         This is the DN name of the subject in rfc2253 format.
76      Name-Email: <string>
77         The is an email address for the altSubjectName
78      Name-DNS: <string> 
79         The is an DNS name for the altSubjectName
80      Name-URI: <string> 
81         The is an URI for the altSubjectName
82
83 Here is an example:
84 $ cat >foo <<EOF
85 %echo Generating a standard key
86 Key-Type: RSA
87 Key-Length: 2048
88 Name-DN: CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=Düsseldorf,C=DE
89 Name-Email: joe@foo.bar
90 # Do a commit here, so that we can later print "done" :-)
91 %commit
92 %echo done
93 EOF
94 */
95
96
97 #include <config.h>
98 #include <stdio.h>
99 #include <stdlib.h>
100 #include <string.h>
101 #include <errno.h>
102 #include <unistd.h> 
103 #include <time.h>
104 #include <assert.h>
105
106 #include "gpgsm.h"
107 #include <gcrypt.h>
108 #include <ksba.h>
109
110 #include "keydb.h"
111 #include "i18n.h"
112
113
114 enum para_name {
115   pKEYTYPE,
116   pKEYLENGTH,
117   pKEYGRIP,
118   pKEYUSAGE,
119   pNAMEDN,
120   pNAMEEMAIL,
121   pNAMEDNS,
122   pNAMEURI
123 };
124
125 struct para_data_s {
126   struct para_data_s *next;
127   int lnr;
128   enum para_name key;
129   union {
130     unsigned int usage; 
131     char value[1];
132   } u;
133 };
134
135 struct reqgen_ctrl_s {
136   int lnr;
137   int dryrun;
138   ksba_writer_t writer;
139 };
140
141
142 static const char oidstr_keyUsage[] = "2.5.29.15";
143
144
145 static int proc_parameters (ctrl_t ctrl,
146                             struct para_data_s *para,
147                             struct reqgen_ctrl_s *outctrl);
148 static int create_request (ctrl_t ctrl,
149                            struct para_data_s *para,
150                            const char *carddirect,
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, estream_t 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 (es_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 && !ascii_isspace (*p); p++)
298             ;
299           if (*p)
300             *p++ = 0;
301           for (; ascii_isspace (*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 (es_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   char *cardkeyid = NULL;
456
457   /* Check that we have all required parameters; */
458   assert (get_parameter (para, pKEYTYPE, 0));
459
460   /* We can only use RSA for now.  There is a problem with pkcs-10 on
461      how to use ElGamal because it is expected that a PK algorithm can
462      always be used for signing. Another problem is that on-card
463      generated encryption keys may not be used for signing.  */
464   i = get_parameter_algo (para, pKEYTYPE);
465   if (!i && (s = get_parameter_value (para, pKEYTYPE, 0)) && *s)
466     {
467       /* Hack to allow creation of certificates directly from a smart
468          card.  For example: "Key-Type: card:OPENPGP.3".  */
469       if (!strncmp (s, "card:", 5) && s[5])
470         cardkeyid = xtrystrdup (s+5);
471     }
472   if ( (i < 1 || i != GCRY_PK_RSA) && !cardkeyid )
473     {
474       r = get_parameter (para, pKEYTYPE, 0);
475       log_error (_("line %d: invalid algorithm\n"), r->lnr);
476       return gpg_error (GPG_ERR_INV_PARAMETER);
477     }
478   
479   /* Check the keylength.  NOTE: If you change this make sure that it
480      macthes the gpgconflist item in gpgsm.c  */
481   if (!get_parameter (para, pKEYLENGTH, 0))
482     nbits = 2048;
483   else
484     nbits = get_parameter_uint (para, pKEYLENGTH);
485   if ((nbits < 1024 || nbits > 4096) && !cardkeyid)
486     {
487       /* The BSI specs dated 2002-11-25 don't allow lengths below 1024. */
488       r = get_parameter (para, pKEYLENGTH, 0);
489       log_error (_("line %d: invalid key length %u (valid are %d to %d)\n"),
490                  r->lnr, nbits, 1024, 4096);
491       xfree (cardkeyid);
492       return gpg_error (GPG_ERR_INV_PARAMETER);
493     }
494     
495   /* Check the usage. */
496   if (parse_parameter_usage (para, pKEYUSAGE))
497     {
498       xfree (cardkeyid);
499       return gpg_error (GPG_ERR_INV_PARAMETER);
500     }
501
502   /* Check that there is a subject name and that this DN fits our
503      requirements. */
504   if (!(s=get_parameter_value (para, pNAMEDN, 0)))
505     {
506       r = get_parameter (para, pNAMEDN, 0);
507       log_error (_("line %d: no subject name given\n"), r->lnr);
508       xfree (cardkeyid);
509       return gpg_error (GPG_ERR_INV_PARAMETER);
510     }
511   err = ksba_dn_teststr (s, 0, &erroff, &errlen);
512   if (err)
513     {
514       r = get_parameter (para, pNAMEDN, 0);
515       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_NAME)
516         log_error (_("line %d: invalid subject name label `%.*s'\n"),
517                    r->lnr, (int)errlen, s+erroff);
518       else
519         log_error (_("line %d: invalid subject name `%s' at pos %d\n"),
520                    r->lnr, s, (int)erroff);
521
522       xfree (cardkeyid);
523       return gpg_error (GPG_ERR_INV_PARAMETER);
524     }
525
526   /* Check that the optional email address is okay. */
527   for (seq=0; (s=get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
528     { 
529       if (has_invalid_email_chars (s)
530           || *s == '@'
531           || s[strlen(s)-1] == '@'
532           || s[strlen(s)-1] == '.'
533           || strstr(s, ".."))
534         {
535           r = get_parameter (para, pNAMEEMAIL, seq);
536           log_error (_("line %d: not a valid email address\n"), r->lnr);
537           xfree (cardkeyid);
538           return gpg_error (GPG_ERR_INV_PARAMETER);
539         }
540     }
541
542   if (cardkeyid) /* Take the key from the current smart card. */
543     {
544       rc = gpgsm_agent_readkey (ctrl, 1, cardkeyid, &public);
545       if (rc)
546         {
547           r = get_parameter (para, pKEYTYPE, 0);
548           log_error (_("line %d: error reading key `%s' from card: %s\n"),
549                      r->lnr, cardkeyid, gpg_strerror (rc));
550           xfree (cardkeyid);
551           return rc;
552         }
553     }
554   else if ((s=get_parameter_value (para, pKEYGRIP, 0))) /* Use existing key.*/
555     {
556       rc = gpgsm_agent_readkey (ctrl, 0, s, &public);
557       if (rc)
558         {
559           r = get_parameter (para, pKEYTYPE, 0);
560           log_error (_("line %d: error getting key by keygrip `%s': %s\n"),
561                      r->lnr, s, gpg_strerror (rc));
562           xfree (cardkeyid);
563           return rc;
564         }
565     }
566   else /* Generate new key.  */
567     {
568       sprintf (numbuf, "%u", nbits);
569       snprintf ((char*)keyparms, DIM (keyparms)-1, 
570                 "(6:genkey(3:rsa(5:nbits%d:%s)))",
571                 (int)strlen (numbuf), numbuf);
572       rc = gpgsm_agent_genkey (ctrl, keyparms, &public);
573       if (rc)
574         {
575           r = get_parameter (para, pKEYTYPE, 0);
576           log_error (_("line %d: key generation failed: %s <%s>\n"),
577                      r->lnr, gpg_strerror (rc), gpg_strsource (rc));
578           xfree (cardkeyid);
579           return rc;
580         }
581     }
582
583   rc = create_request (ctrl, para, cardkeyid, public, outctrl);
584   xfree (public);
585   xfree (cardkeyid);
586
587   return rc;
588 }
589
590
591 /* Parameters are checked, the key pair has been created.  Now
592    generate the request and write it out */
593 static int
594 create_request (ctrl_t ctrl, 
595                 struct para_data_s *para, 
596                 const char *carddirect,
597                 ksba_const_sexp_t public,
598                 struct reqgen_ctrl_s *outctrl)
599 {
600   ksba_certreq_t cr;
601   gpg_error_t err;
602   gcry_md_hd_t md;
603   ksba_stop_reason_t stopreason;
604   int rc = 0;
605   const char *s;
606   unsigned int use;
607   int seq;
608   char *buf, *p;
609   size_t len;
610   char numbuf[30];
611
612   err = ksba_certreq_new (&cr);
613   if (err)
614     return err;
615
616   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0);
617   if (rc)
618     {
619       log_error ("md_open failed: %s\n", gpg_strerror (rc));
620       goto leave;
621     }
622   if (DBG_HASHING)
623     gcry_md_start_debug (md, "cr.cri");
624
625   ksba_certreq_set_hash_function (cr, HASH_FNC, md);
626   ksba_certreq_set_writer (cr, outctrl->writer);
627   
628   err = ksba_certreq_add_subject (cr, get_parameter_value (para, pNAMEDN, 0));
629   if (err)
630     {
631       log_error ("error setting the subject's name: %s\n",
632                  gpg_strerror (err));
633       rc = err;
634       goto leave;
635     }
636
637   for (seq=0; (s = get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
638     {
639       buf = xtrymalloc (strlen (s) + 3);
640       if (!buf)
641         {
642           rc = out_of_core ();
643           goto leave;
644         }
645       *buf = '<';
646       strcpy (buf+1, s);
647       strcat (buf+1, ">");
648       err = ksba_certreq_add_subject (cr, buf);
649       xfree (buf);
650       if (err)
651         {
652           log_error ("error setting the subject's alternate name: %s\n",
653                      gpg_strerror (err));
654           rc = err;
655           goto leave;
656         }
657     }
658
659   for (seq=0; (s = get_parameter_value (para, pNAMEDNS, seq)); seq++)
660     {
661       len = strlen (s);
662       assert (len);
663       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
664       buf = p = xtrymalloc (11 + strlen (numbuf) + len + 3);
665       if (!buf)
666         {
667           rc = out_of_core ();
668           goto leave;
669         }
670       p = stpcpy (p, "(8:dns-name");
671       p = stpcpy (p, numbuf);
672       p = stpcpy (p, s);
673       strcpy (p, ")");
674
675       err = ksba_certreq_add_subject (cr, buf);
676       xfree (buf);
677       if (err)
678         {
679           log_error ("error setting the subject's alternate name: %s\n",
680                      gpg_strerror (err));
681           rc = err;
682           goto leave;
683         }
684     }
685
686   for (seq=0; (s = get_parameter_value (para, pNAMEURI, seq)); seq++)
687     {
688       len = strlen (s);
689       assert (len);
690       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
691       buf = p = xtrymalloc (6 + strlen (numbuf) + len + 3);
692       if (!buf)
693         {
694           rc = out_of_core ();
695           goto leave;
696         }
697       p = stpcpy (p, "(3:uri");
698       p = stpcpy (p, numbuf);
699       p = stpcpy (p, s);
700       strcpy (p, ")");
701
702       err = ksba_certreq_add_subject (cr, buf);
703       xfree (buf);
704       if (err)
705         {
706           log_error ("error setting the subject's alternate name: %s\n",
707                      gpg_strerror (err));
708           rc = err;
709           goto leave;
710         }
711     }
712
713
714   err = ksba_certreq_set_public_key (cr, public);
715   if (err)
716     {
717       log_error ("error setting the public key: %s\n",
718                  gpg_strerror (err));
719       rc = err;
720       goto leave;
721     }
722
723   
724   use = get_parameter_uint (para, pKEYUSAGE);
725   if (use == GCRY_PK_USAGE_SIGN)
726     {
727       /* For signing only we encode the bits:
728          KSBA_KEYUSAGE_DIGITAL_SIGNATURE
729          KSBA_KEYUSAGE_NON_REPUDIATION */
730       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1, 
731                                         "\x03\x02\x06\xC0", 4);
732     }
733   else if (use == GCRY_PK_USAGE_ENCR)
734     {
735       /* For encrypt only we encode the bits:
736          KSBA_KEYUSAGE_KEY_ENCIPHERMENT
737          KSBA_KEYUSAGE_DATA_ENCIPHERMENT */
738       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1, 
739                                         "\x03\x02\x04\x30", 4);
740     }
741   else
742     err = 0; /* Both or none given: don't request one. */
743   if (err)
744     {
745       log_error ("error setting the key usage: %s\n",
746                  gpg_strerror (err));
747       rc = err;
748       goto leave;
749     }
750
751                
752   do
753     {
754       err = ksba_certreq_build (cr, &stopreason);
755       if (err)
756         {
757           log_error ("ksba_certreq_build failed: %s\n", gpg_strerror (err));
758           rc = err;
759           goto leave;
760         }
761       if (stopreason == KSBA_SR_NEED_SIG)
762         {
763           gcry_sexp_t s_pkey;
764           size_t n;
765           unsigned char grip[20];
766           char hexgrip[41];
767           unsigned char *sigval;
768           size_t siglen;
769
770           n = gcry_sexp_canon_len (public, 0, NULL, NULL);
771           if (!n)
772             {
773               log_error ("libksba did not return a proper S-Exp\n");
774               rc = gpg_error (GPG_ERR_BUG);
775               goto leave;
776             }
777           rc = gcry_sexp_sscan (&s_pkey, NULL, (const char*)public, n);
778           if (rc)
779             {
780               log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
781               goto leave;
782             }
783           if ( !gcry_pk_get_keygrip (s_pkey, grip) )
784             {
785               rc = gpg_error (GPG_ERR_GENERAL);
786               log_error ("can't figure out the keygrip\n");
787               gcry_sexp_release (s_pkey);
788               goto leave;
789             }
790           gcry_sexp_release (s_pkey);
791           bin2hex (grip, 20, hexgrip);
792
793           log_info ("about to sign CSR for key: &%s\n", hexgrip); 
794
795           if (carddirect)
796             rc = gpgsm_scd_pksign (ctrl, carddirect, NULL,
797                                      gcry_md_read(md, GCRY_MD_SHA1), 
798                                      gcry_md_get_algo_dlen (GCRY_MD_SHA1),
799                                      GCRY_MD_SHA1,
800                                      &sigval, &siglen);
801           else
802             {
803               char *orig_codeset;
804               char *desc;
805
806               orig_codeset = i18n_switchto_utf8 ();
807               desc = percent_plus_escape 
808                 (_("To complete this certificate request please enter"
809                    " the passphrase for the key you just created once"
810                    " more.\n"));
811               i18n_switchback (orig_codeset);
812               rc = gpgsm_agent_pksign (ctrl, hexgrip, desc,
813                                        gcry_md_read(md, GCRY_MD_SHA1), 
814                                        gcry_md_get_algo_dlen (GCRY_MD_SHA1),
815                                        GCRY_MD_SHA1,
816                                        &sigval, &siglen);
817               xfree (desc);
818             }
819           if (rc)
820             {
821               log_error ("signing failed: %s\n", gpg_strerror (rc));
822               goto leave;
823             }
824           
825           err = ksba_certreq_set_sig_val (cr, sigval);
826           xfree (sigval);
827           if (err)
828             {
829               log_error ("failed to store the sig_val: %s\n",
830                          gpg_strerror (err));
831               rc = err;
832               goto leave;
833             }
834         }
835     }
836   while (stopreason != KSBA_SR_READY);   
837
838
839  leave:
840   gcry_md_close (md);
841   ksba_certreq_release (cr);
842   return rc;  
843 }
844
845
846 \f
847 /* Create a new key by reading the parameters from IN_FP.  Multiple
848    keys may be created */
849 int
850 gpgsm_genkey (ctrl_t ctrl, estream_t in_stream, estream_t out_stream)
851 {
852   int rc;
853   Base64Context b64writer = NULL;
854   ksba_writer_t writer;
855
856   ctrl->pem_name = "CERTIFICATE REQUEST";
857   rc = gpgsm_create_writer (&b64writer, ctrl, NULL, out_stream, &writer);
858   if (rc)
859     {
860       log_error ("can't create writer: %s\n", gpg_strerror (rc));
861       goto leave;
862     }
863
864   rc = read_parameters (ctrl, in_stream, writer);
865   if (rc)
866     {
867       log_error ("error creating certificate request: %s <%s>\n",
868                  gpg_strerror (rc), gpg_strsource (rc));
869       goto leave;
870     }
871
872   rc = gpgsm_finish_writer (b64writer);
873   if (rc) 
874     {
875       log_error ("write failed: %s\n", gpg_strerror (rc));
876       goto leave;
877     }
878
879   gpgsm_status (ctrl, STATUS_KEY_CREATED, "P");
880   log_info ("certificate request created\n");
881
882  leave:
883   gpgsm_destroy_writer (b64writer);
884   return rc;
885 }
886