dns-cert.c: Use constants for better readability.
[gnupg.git] / sm / certreqgen.c
1 /* certreqgen.c - Generate a key and a certification [request]
2  * Copyright (C) 2002, 2003, 2005, 2007, 2010,
3  *               2011 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 parameter file is described in the manual under
23    "Unattended Usage".
24
25    Here is an example:
26      $ cat >foo <<EOF
27      %echo Generating a standard key
28      Key-Type: RSA
29      Key-Length: 2048
30      Name-DN: CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=Ddorf,C=DE
31      Name-Email: joe@foo.bar
32      # Do a commit here, so that we can later print a "done"
33      %commit
34      %echo done
35      EOF
36 */
37
38
39 #include <config.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <errno.h>
44 #include <unistd.h>
45 #include <time.h>
46 #include <assert.h>
47
48 #include "gpgsm.h"
49 #include <gcrypt.h>
50 #include <ksba.h>
51
52 #include "keydb.h"
53 #include "i18n.h"
54
55
56 enum para_name
57   {
58     pKEYTYPE,
59     pKEYLENGTH,
60     pKEYGRIP,
61     pKEYUSAGE,
62     pNAMEDN,
63     pNAMEEMAIL,
64     pNAMEDNS,
65     pNAMEURI,
66     pSERIAL,
67     pISSUERDN,
68     pNOTBEFORE,
69     pNOTAFTER,
70     pSIGNINGKEY,
71     pHASHALGO
72   };
73
74 struct para_data_s
75 {
76   struct para_data_s *next;
77   int lnr;
78   enum para_name key;
79   union {
80     unsigned int usage;
81     char value[1];
82   } u;
83 };
84
85 struct reqgen_ctrl_s
86 {
87   int lnr;
88   int dryrun;
89 };
90
91
92 static const char oidstr_keyUsage[] = "2.5.29.15";
93 static const char oidstr_basicConstraints[] = "2.5.29.19";
94 static const char oidstr_standaloneCertificate[] = "1.3.6.1.4.1.11591.2.2.1";
95
96
97 static int proc_parameters (ctrl_t ctrl,
98                             struct para_data_s *para,
99                             estream_t out_fp,
100                             struct reqgen_ctrl_s *outctrl);
101 static int create_request (ctrl_t ctrl,
102                            struct para_data_s *para,
103                            const char *carddirect,
104                            ksba_const_sexp_t public,
105                            ksba_const_sexp_t sigkey,
106                            ksba_writer_t writer);
107
108
109 \f
110 static void
111 release_parameter_list (struct para_data_s *r)
112 {
113   struct para_data_s *r2;
114
115   for (; r ; r = r2)
116     {
117       r2 = r->next;
118       xfree(r);
119     }
120 }
121
122 static struct para_data_s *
123 get_parameter (struct para_data_s *para, enum para_name key, int seq)
124 {
125   struct para_data_s *r;
126
127   for (r = para; r ; r = r->next)
128     if ( r->key == key && !seq--)
129       return r;
130   return NULL;
131 }
132
133 static const char *
134 get_parameter_value (struct para_data_s *para, enum para_name key, int seq)
135 {
136   struct para_data_s *r = get_parameter (para, key, seq);
137   return (r && *r->u.value)? r->u.value : NULL;
138 }
139
140 static int
141 get_parameter_algo (struct para_data_s *para, enum para_name key)
142 {
143   struct para_data_s *r = get_parameter (para, key, 0);
144   if (!r)
145     return -1;
146   if (digitp (r->u.value))
147     return atoi( r->u.value );
148   return gcry_pk_map_name (r->u.value);
149 }
150
151 /* Parse the usage parameter.  Returns 0 on success.  Note that we
152    only care about sign and encrypt and don't (yet) allow all the
153    other X.509 usage to be specified; instead we will use a fixed
154    mapping to the X.509 usage flags. */
155 static int
156 parse_parameter_usage (struct para_data_s *para, enum para_name key)
157 {
158   struct para_data_s *r = get_parameter (para, key, 0);
159   char *p, *pn;
160   unsigned int use;
161
162   if (!r)
163     return 0; /* none (this is an optional parameter)*/
164
165   use = 0;
166   pn = r->u.value;
167   while ( (p = strsep (&pn, " \t,")) )
168     {
169       if (!*p)
170         ;
171       else if ( !ascii_strcasecmp (p, "sign") )
172         use |= GCRY_PK_USAGE_SIGN;
173       else if ( !ascii_strcasecmp (p, "encrypt") )
174         use |= GCRY_PK_USAGE_ENCR;
175       else
176         {
177           log_error ("line %d: invalid usage list\n", r->lnr);
178           return -1; /* error */
179         }
180     }
181   r->u.usage = use;
182   return 0;
183 }
184
185
186 static unsigned int
187 get_parameter_uint (struct para_data_s *para, enum para_name key)
188 {
189   struct para_data_s *r = get_parameter (para, key, 0);
190
191   if (!r)
192     return 0;
193
194   if (r->key == pKEYUSAGE)
195     return r->u.usage;
196
197   return (unsigned int)strtoul (r->u.value, NULL, 10);
198 }
199
200
201
202 /* Read the certificate generation parameters from FP and generate
203    (all) certificate requests.  */
204 static int
205 read_parameters (ctrl_t ctrl, estream_t fp, estream_t out_fp)
206 {
207   static struct {
208     const char *name;
209     enum para_name key;
210     int allow_dups;
211   } keywords[] = {
212     { "Key-Type",       pKEYTYPE},
213     { "Key-Length",     pKEYLENGTH },
214     { "Key-Grip",       pKEYGRIP },
215     { "Key-Usage",      pKEYUSAGE },
216     { "Name-DN",        pNAMEDN },
217     { "Name-Email",     pNAMEEMAIL, 1 },
218     { "Name-DNS",       pNAMEDNS, 1 },
219     { "Name-URI",       pNAMEURI, 1 },
220     { "Serial",         pSERIAL },
221     { "Issuer-DN",      pISSUERDN },
222     { "Creation-Date",  pNOTBEFORE },
223     { "Not-Before",     pNOTBEFORE },
224     { "Expire-Date",    pNOTAFTER },
225     { "Not-After",      pNOTAFTER },
226     { "Signing-Key",    pSIGNINGKEY },
227     { "Hash-Algo",      pHASHALGO },
228     { NULL, 0 }
229   };
230   char line[1024], *p;
231   const char *err = NULL;
232   struct para_data_s *para, *r;
233   int i, rc = 0, any = 0;
234   struct reqgen_ctrl_s outctrl;
235
236   memset (&outctrl, 0, sizeof (outctrl));
237
238   err = NULL;
239   para = NULL;
240   while (es_fgets (line, DIM(line)-1, fp) )
241     {
242       char *keyword, *value;
243
244       outctrl.lnr++;
245       if (*line && line[strlen(line)-1] != '\n')
246         {
247           err = "line too long";
248           break;
249         }
250       for (p=line; spacep (p); p++)
251         ;
252       if (!*p || *p == '#')
253         continue;
254
255       keyword = p;
256       if (*keyword == '%')
257         {
258           for (; *p && !ascii_isspace (*p); p++)
259             ;
260           if (*p)
261             *p++ = 0;
262           for (; ascii_isspace (*p); p++)
263             ;
264           value = p;
265           trim_trailing_spaces (value);
266
267           if (!ascii_strcasecmp (keyword, "%echo"))
268             log_info ("%s\n", value);
269           else if (!ascii_strcasecmp (keyword, "%dry-run"))
270             outctrl.dryrun = 1;
271           else if (!ascii_strcasecmp( keyword, "%commit"))
272             {
273               rc = proc_parameters (ctrl, para, out_fp, &outctrl);
274               if (rc)
275                 goto leave;
276               any = 1;
277               release_parameter_list (para);
278               para = NULL;
279             }
280           else
281             log_info ("skipping control `%s' (%s)\n", keyword, value);
282
283           continue;
284         }
285
286
287       if (!(p = strchr (p, ':')) || p == keyword)
288         {
289           err = "missing colon";
290           break;
291         }
292       if (*p)
293         *p++ = 0;
294       for (; spacep (p); p++)
295         ;
296       if (!*p)
297         {
298           err = "missing argument";
299           break;
300         }
301       value = p;
302       trim_trailing_spaces (value);
303
304       for (i=0; (keywords[i].name
305                  && ascii_strcasecmp (keywords[i].name, keyword)); i++)
306         ;
307       if (!keywords[i].name)
308         {
309           err = "unknown keyword";
310           break;
311         }
312       if (keywords[i].key != pKEYTYPE && !para)
313         {
314           err = "parameter block does not start with \"Key-Type\"";
315           break;
316         }
317
318       if (keywords[i].key == pKEYTYPE && para)
319         {
320           rc = proc_parameters (ctrl, para, out_fp, &outctrl);
321           if (rc)
322             goto leave;
323           any = 1;
324           release_parameter_list (para);
325           para = NULL;
326         }
327       else if (!keywords[i].allow_dups)
328         {
329           for (r = para; r && r->key != keywords[i].key; r = r->next)
330             ;
331           if (r)
332             {
333               err = "duplicate keyword";
334               break;
335             }
336         }
337
338       r = xtrycalloc (1, sizeof *r + strlen( value ));
339       if (!r)
340         {
341           err = "out of core";
342           break;
343         }
344       r->lnr = outctrl.lnr;
345       r->key = keywords[i].key;
346       strcpy (r->u.value, value);
347       r->next = para;
348       para = r;
349     }
350
351   if (err)
352     {
353       log_error ("line %d: %s\n", outctrl.lnr, err);
354       rc = gpg_error (GPG_ERR_GENERAL);
355     }
356   else if (es_ferror(fp))
357     {
358       log_error ("line %d: read error: %s\n", outctrl.lnr, strerror(errno) );
359       rc = gpg_error (GPG_ERR_GENERAL);
360     }
361   else if (para)
362     {
363       rc = proc_parameters (ctrl, para, out_fp, &outctrl);
364       if (rc)
365         goto leave;
366       any = 1;
367     }
368
369   if (!rc && !any)
370     rc = gpg_error (GPG_ERR_NO_DATA);
371
372  leave:
373   release_parameter_list (para);
374   return rc;
375 }
376
377 /* check whether there are invalid characters in the email address S */
378 static int
379 has_invalid_email_chars (const char *s)
380 {
381   int at_seen=0;
382   static char valid_chars[] = "01234567890_-."
383                               "abcdefghijklmnopqrstuvwxyz"
384                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
385   for (; *s; s++)
386     {
387       if (*s & 0x80)
388         return 1;
389       if (*s == '@')
390         at_seen++;
391       else if (!at_seen && !( !!strchr (valid_chars, *s) || *s == '+'))
392         return 1;
393       else if (at_seen && !strchr (valid_chars, *s))
394         return 1;
395     }
396   return at_seen != 1;
397 }
398
399
400 /* Check that all required parameters are given and perform the action */
401 static int
402 proc_parameters (ctrl_t ctrl, struct para_data_s *para,
403                  estream_t out_fp, struct reqgen_ctrl_s *outctrl)
404 {
405   gpg_error_t err;
406   struct para_data_s *r;
407   const char *s, *string;
408   int i;
409   unsigned int nbits;
410   char numbuf[20];
411   unsigned char keyparms[100];
412   int rc = 0;
413   ksba_sexp_t public;
414   ksba_sexp_t sigkey = NULL;
415   int seq;
416   size_t erroff, errlen;
417   char *cardkeyid = NULL;
418
419   /* Check that we have all required parameters; */
420   assert (get_parameter (para, pKEYTYPE, 0));
421
422   /* We can only use RSA for now.  There is a problem with pkcs-10 on
423      how to use ElGamal because it is expected that a PK algorithm can
424      always be used for signing. Another problem is that on-card
425      generated encryption keys may not be used for signing.  */
426   i = get_parameter_algo (para, pKEYTYPE);
427   if (!i && (s = get_parameter_value (para, pKEYTYPE, 0)) && *s)
428     {
429       /* Hack to allow creation of certificates directly from a smart
430          card.  For example: "Key-Type: card:OPENPGP.3".  */
431       if (!strncmp (s, "card:", 5) && s[5])
432         cardkeyid = xtrystrdup (s+5);
433     }
434   if ( (i < 1 || i != GCRY_PK_RSA) && !cardkeyid )
435     {
436       r = get_parameter (para, pKEYTYPE, 0);
437       log_error (_("line %d: invalid algorithm\n"), r->lnr);
438       return gpg_error (GPG_ERR_INV_PARAMETER);
439     }
440
441   /* Check the keylength.  NOTE: If you change this make sure that it
442      macthes the gpgconflist item in gpgsm.c  */
443   if (!get_parameter (para, pKEYLENGTH, 0))
444     nbits = 2048;
445   else
446     nbits = get_parameter_uint (para, pKEYLENGTH);
447   if ((nbits < 1024 || nbits > 4096) && !cardkeyid)
448     {
449       /* The BSI specs dated 2002-11-25 don't allow lengths below 1024. */
450       r = get_parameter (para, pKEYLENGTH, 0);
451       log_error (_("line %d: invalid key length %u (valid are %d to %d)\n"),
452                  r->lnr, nbits, 1024, 4096);
453       xfree (cardkeyid);
454       return gpg_error (GPG_ERR_INV_PARAMETER);
455     }
456
457   /* Check the usage. */
458   if (parse_parameter_usage (para, pKEYUSAGE))
459     {
460       xfree (cardkeyid);
461       return gpg_error (GPG_ERR_INV_PARAMETER);
462     }
463
464   /* Check that there is a subject name and that this DN fits our
465      requirements. */
466   if (!(s=get_parameter_value (para, pNAMEDN, 0)))
467     {
468       r = get_parameter (para, pNAMEDN, 0);
469       log_error (_("line %d: no subject name given\n"), r->lnr);
470       xfree (cardkeyid);
471       return gpg_error (GPG_ERR_INV_PARAMETER);
472     }
473   err = ksba_dn_teststr (s, 0, &erroff, &errlen);
474   if (err)
475     {
476       r = get_parameter (para, pNAMEDN, 0);
477       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_NAME)
478         log_error (_("line %d: invalid subject name label `%.*s'\n"),
479                    r->lnr, (int)errlen, s+erroff);
480       else
481         log_error (_("line %d: invalid subject name `%s' at pos %d\n"),
482                    r->lnr, s, (int)erroff);
483
484       xfree (cardkeyid);
485       return gpg_error (GPG_ERR_INV_PARAMETER);
486     }
487
488   /* Check that the optional email address is okay. */
489   for (seq=0; (s=get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
490     {
491       if (has_invalid_email_chars (s)
492           || *s == '@'
493           || s[strlen(s)-1] == '@'
494           || s[strlen(s)-1] == '.'
495           || strstr(s, ".."))
496         {
497           r = get_parameter (para, pNAMEEMAIL, seq);
498           log_error (_("line %d: not a valid email address\n"), r->lnr);
499           xfree (cardkeyid);
500           return gpg_error (GPG_ERR_INV_PARAMETER);
501         }
502     }
503
504   /* Check the optional serial number.  */
505   string = get_parameter_value (para, pSERIAL, 0);
506   if (string)
507     {
508       if (!strcmp (string, "random"))
509         ; /* Okay.  */
510       else
511         {
512           for (s=string, i=0; hexdigitp (s); s++, i++)
513             ;
514           if (*s)
515             {
516               r = get_parameter (para, pSERIAL, 0);
517               log_error (_("line %d: invalid serial number\n"), r->lnr);
518               xfree (cardkeyid);
519               return gpg_error (GPG_ERR_INV_PARAMETER);
520             }
521         }
522     }
523
524   /* Check the optional issuer DN.  */
525   string = get_parameter_value (para, pISSUERDN, 0);
526   if (string)
527     {
528       err = ksba_dn_teststr (string, 0, &erroff, &errlen);
529       if (err)
530         {
531           r = get_parameter (para, pISSUERDN, 0);
532           if (gpg_err_code (err) == GPG_ERR_UNKNOWN_NAME)
533             log_error (_("line %d: invalid issuer name label `%.*s'\n"),
534                        r->lnr, (int)errlen, string+erroff);
535           else
536             log_error (_("line %d: invalid issuer name `%s' at pos %d\n"),
537                        r->lnr, string, (int)erroff);
538           xfree (cardkeyid);
539           return gpg_error (GPG_ERR_INV_PARAMETER);
540         }
541     }
542
543   /* Check the optional creation date.  */
544   string = get_parameter_value (para, pNOTBEFORE, 0);
545   if (string && !string2isotime (NULL, string))
546     {
547       r = get_parameter (para, pNOTBEFORE, 0);
548       log_error (_("line %d: invalid date given\n"), r->lnr);
549       xfree (cardkeyid);
550       return gpg_error (GPG_ERR_INV_PARAMETER);
551     }
552
553
554   /* Check the optional expire date.  */
555   string = get_parameter_value (para, pNOTAFTER, 0);
556   if (string && !string2isotime (NULL, string))
557     {
558       r = get_parameter (para, pNOTAFTER, 0);
559       log_error (_("line %d: invalid date given\n"), r->lnr);
560       xfree (cardkeyid);
561       return gpg_error (GPG_ERR_INV_PARAMETER);
562     }
563
564   /* Get the optional signing key.  */
565   string = get_parameter_value (para, pSIGNINGKEY, 0);
566   if (string)
567     {
568       rc = gpgsm_agent_readkey (ctrl, 0, string, &sigkey);
569       if (rc)
570         {
571           r = get_parameter (para, pKEYTYPE, 0);
572           log_error (_("line %d: error getting signing key by keygrip `%s'"
573                        ": %s\n"), r->lnr, s, gpg_strerror (rc));
574           xfree (cardkeyid);
575           return rc;
576         }
577     }
578
579   /* Check the optional hash-algo.  */
580   {
581     int mdalgo;
582
583     string = get_parameter_value (para, pHASHALGO, 0);
584     if (string && !((mdalgo = gcry_md_map_name (string))
585                     && (mdalgo == GCRY_MD_SHA1
586                         || mdalgo == GCRY_MD_SHA256
587                         || mdalgo == GCRY_MD_SHA384
588                         || mdalgo == GCRY_MD_SHA512)))
589       {
590         r = get_parameter (para, pHASHALGO, 0);
591         log_error (_("line %d: invalid hash algorithm given\n"), r->lnr);
592         xfree (cardkeyid);
593         return gpg_error (GPG_ERR_INV_PARAMETER);
594       }
595   }
596
597   /* Create or retrieve the public key.  */
598   if (cardkeyid) /* Take the key from the current smart card. */
599     {
600       rc = gpgsm_agent_readkey (ctrl, 1, cardkeyid, &public);
601       if (rc)
602         {
603           r = get_parameter (para, pKEYTYPE, 0);
604           log_error (_("line %d: error reading key `%s' from card: %s\n"),
605                      r->lnr, cardkeyid, gpg_strerror (rc));
606           xfree (sigkey);
607           xfree (cardkeyid);
608           return rc;
609         }
610     }
611   else if ((s=get_parameter_value (para, pKEYGRIP, 0))) /* Use existing key.*/
612     {
613       rc = gpgsm_agent_readkey (ctrl, 0, s, &public);
614       if (rc)
615         {
616           r = get_parameter (para, pKEYTYPE, 0);
617           log_error (_("line %d: error getting key by keygrip `%s': %s\n"),
618                      r->lnr, s, gpg_strerror (rc));
619           xfree (sigkey);
620           xfree (cardkeyid);
621           return rc;
622         }
623     }
624   else if (!outctrl->dryrun) /* Generate new key.  */
625     {
626       sprintf (numbuf, "%u", nbits);
627       snprintf ((char*)keyparms, DIM (keyparms)-1,
628                 "(6:genkey(3:rsa(5:nbits%d:%s)))",
629                 (int)strlen (numbuf), numbuf);
630       rc = gpgsm_agent_genkey (ctrl, keyparms, &public);
631       if (rc)
632         {
633           r = get_parameter (para, pKEYTYPE, 0);
634           log_error (_("line %d: key generation failed: %s <%s>\n"),
635                      r->lnr, gpg_strerror (rc), gpg_strsource (rc));
636           xfree (sigkey);
637           xfree (cardkeyid);
638           return rc;
639         }
640     }
641
642
643   if (!outctrl->dryrun)
644     {
645       Base64Context b64writer = NULL;
646       ksba_writer_t writer;
647       int create_cert ;
648
649       create_cert = !!get_parameter_value (para, pSERIAL, 0);
650
651       ctrl->pem_name = create_cert? "CERTIFICATE" : "CERTIFICATE REQUEST";
652       rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
653       if (rc)
654         log_error ("can't create writer: %s\n", gpg_strerror (rc));
655       else
656         {
657           rc = create_request (ctrl, para, cardkeyid, public, sigkey, writer);
658           if (!rc)
659             {
660               rc = gpgsm_finish_writer (b64writer);
661               if (rc)
662                 log_error ("write failed: %s\n", gpg_strerror (rc));
663               else
664                 {
665                   gpgsm_status (ctrl, STATUS_KEY_CREATED, "P");
666                   log_info ("certificate%s created\n",
667                             create_cert?"":" request");
668                 }
669             }
670           gpgsm_destroy_writer (b64writer);
671         }
672     }
673
674   xfree (sigkey);
675   xfree (public);
676   xfree (cardkeyid);
677
678   return rc;
679 }
680
681
682 /* Parameters are checked, the key pair has been created.  Now
683    generate the request and write it out */
684 static int
685 create_request (ctrl_t ctrl,
686                 struct para_data_s *para,
687                 const char *carddirect,
688                 ksba_const_sexp_t public,
689                 ksba_const_sexp_t sigkey,
690                 ksba_writer_t writer)
691 {
692   ksba_certreq_t cr;
693   gpg_error_t err;
694   gcry_md_hd_t md;
695   ksba_stop_reason_t stopreason;
696   int rc = 0;
697   const char *s, *string;
698   unsigned int use;
699   int seq;
700   char *buf, *p;
701   size_t len;
702   char numbuf[30];
703   ksba_isotime_t atime;
704   int certmode = 0;
705   int mdalgo;
706
707   err = ksba_certreq_new (&cr);
708   if (err)
709     return err;
710
711   string = get_parameter_value (para, pHASHALGO, 0);
712   if (string)
713     mdalgo = gcry_md_map_name (string);
714   else
715     mdalgo = GCRY_MD_SHA1;
716   rc = gcry_md_open (&md, mdalgo, 0);
717   if (rc)
718     {
719       log_error ("md_open failed: %s\n", gpg_strerror (rc));
720       goto leave;
721     }
722   if (DBG_HASHING)
723     gcry_md_debug (md, "cr.cri");
724
725   ksba_certreq_set_hash_function (cr, HASH_FNC, md);
726   ksba_certreq_set_writer (cr, writer);
727
728   err = ksba_certreq_add_subject (cr, get_parameter_value (para, pNAMEDN, 0));
729   if (err)
730     {
731       log_error ("error setting the subject's name: %s\n",
732                  gpg_strerror (err));
733       rc = err;
734       goto leave;
735     }
736
737   for (seq=0; (s = get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
738     {
739       buf = xtrymalloc (strlen (s) + 3);
740       if (!buf)
741         {
742           rc = out_of_core ();
743           goto leave;
744         }
745       *buf = '<';
746       strcpy (buf+1, s);
747       strcat (buf+1, ">");
748       err = ksba_certreq_add_subject (cr, buf);
749       xfree (buf);
750       if (err)
751         {
752           log_error ("error setting the subject's alternate name: %s\n",
753                      gpg_strerror (err));
754           rc = err;
755           goto leave;
756         }
757     }
758
759   for (seq=0; (s = get_parameter_value (para, pNAMEDNS, seq)); seq++)
760     {
761       len = strlen (s);
762       assert (len);
763       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
764       buf = p = xtrymalloc (11 + strlen (numbuf) + len + 3);
765       if (!buf)
766         {
767           rc = out_of_core ();
768           goto leave;
769         }
770       p = stpcpy (p, "(8:dns-name");
771       p = stpcpy (p, numbuf);
772       p = stpcpy (p, s);
773       strcpy (p, ")");
774
775       err = ksba_certreq_add_subject (cr, buf);
776       xfree (buf);
777       if (err)
778         {
779           log_error ("error setting the subject's alternate name: %s\n",
780                      gpg_strerror (err));
781           rc = err;
782           goto leave;
783         }
784     }
785
786   for (seq=0; (s = get_parameter_value (para, pNAMEURI, seq)); seq++)
787     {
788       len = strlen (s);
789       assert (len);
790       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
791       buf = p = xtrymalloc (6 + strlen (numbuf) + len + 3);
792       if (!buf)
793         {
794           rc = out_of_core ();
795           goto leave;
796         }
797       p = stpcpy (p, "(3:uri");
798       p = stpcpy (p, numbuf);
799       p = stpcpy (p, s);
800       strcpy (p, ")");
801
802       err = ksba_certreq_add_subject (cr, buf);
803       xfree (buf);
804       if (err)
805         {
806           log_error ("error setting the subject's alternate name: %s\n",
807                      gpg_strerror (err));
808           rc = err;
809           goto leave;
810         }
811     }
812
813
814   err = ksba_certreq_set_public_key (cr, public);
815   if (err)
816     {
817       log_error ("error setting the public key: %s\n",
818                  gpg_strerror (err));
819       rc = err;
820       goto leave;
821     }
822
823   /* Set key usage flags.  */
824   use = get_parameter_uint (para, pKEYUSAGE);
825   if (use == GCRY_PK_USAGE_SIGN)
826     {
827       /* For signing only we encode the bits:
828          KSBA_KEYUSAGE_DIGITAL_SIGNATURE
829          KSBA_KEYUSAGE_NON_REPUDIATION */
830       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1,
831                                         "\x03\x02\x06\xC0", 4);
832     }
833   else if (use == GCRY_PK_USAGE_ENCR)
834     {
835       /* For encrypt only we encode the bits:
836          KSBA_KEYUSAGE_KEY_ENCIPHERMENT
837          KSBA_KEYUSAGE_DATA_ENCIPHERMENT */
838       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1,
839                                         "\x03\x02\x04\x30", 4);
840     }
841   else
842     err = 0; /* Both or none given: don't request one. */
843   if (err)
844     {
845       log_error ("error setting the key usage: %s\n",
846                  gpg_strerror (err));
847       rc = err;
848       goto leave;
849     }
850
851
852   /* See whether we want to create an X.509 certificate.  */
853   string = get_parameter_value (para, pSERIAL, 0);
854   if (string)
855     {
856       certmode = 1;
857
858       /* Store the serial number.  */
859       if (!strcmp (string, "random"))
860         {
861           char snbuf[3+8+1];
862
863           memcpy (snbuf, "(8:", 3);
864           gcry_create_nonce (snbuf+3, 8);
865           /* Clear high bit to guarantee a positive integer.  */
866           snbuf[3] &= 0x7f;
867           snbuf[3+8] = ')';
868           err = ksba_certreq_set_serial (cr, snbuf);
869         }
870       else
871         {
872           char *hexbuf;
873
874           /* Allocate a buffer large enough to prefix the string with
875              a '0' so to have an even number of digits.  Prepend two
876              further '0' so that the binary result will have a leading
877              0 byte and thus can't be the representation of a negative
878              number.  Note that ksba_certreq_set_serial strips all
879              unneeded leading 0 bytes.  */
880           hexbuf = p = xtrymalloc (2 + 1 + strlen (string) + 1);
881           if (!hexbuf)
882             {
883               err = gpg_error_from_syserror ();
884               goto leave;
885             }
886           if ((strlen (string) & 1))
887             *p++ = '0';
888           *p++ = '0';
889           *p++ = '0';
890           strcpy (p, string);
891           for (p=hexbuf, len=0; p[0] && p[1]; p += 2)
892             ((unsigned char*)hexbuf)[len++] = xtoi_2 (s);
893           /* Now build the S-expression.  */
894           snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
895           buf = p = xtrymalloc (1 + strlen (numbuf) + len + 1 + 1);
896           if (!buf)
897             {
898               err = gpg_error_from_syserror ();
899               xfree (hexbuf);
900               goto leave;
901             }
902           p = stpcpy (stpcpy (buf, "("), numbuf);
903           memcpy (p, hexbuf, len);
904           p += len;
905           strcpy (p, ")");
906           xfree (hexbuf);
907           err = ksba_certreq_set_serial (cr, buf);
908           xfree (buf);
909         }
910       if (err)
911         {
912           log_error ("error setting the serial number: %s\n",
913                      gpg_strerror (err));
914           goto leave;
915         }
916
917
918       /* Store the issuer DN.  If no issuer DN is given and no signing
919          key has been set we add the standalone extension and the
920          basic constraints to mark it as a self-signed CA
921          certificate.  */
922       string = get_parameter_value (para, pISSUERDN, 0);
923       if (string)
924         {
925           /* Issuer DN given.  Note that this may be the same as the
926              subject DN and thus this could as well be a self-signed
927              certificate.  However the caller needs to explicitly
928              specify basicConstraints and so forth.  */
929           err = ksba_certreq_set_issuer (cr, string);
930           if (err)
931             {
932               log_error ("error setting the issuer DN: %s\n",
933                          gpg_strerror (err));
934               goto leave;
935             }
936
937         }
938       else if (!string && !sigkey)
939         {
940           /* Self-signed certificate requested.  Add basicConstraints
941              and the custom GnuPG standalone extension.  */
942           err = ksba_certreq_add_extension (cr, oidstr_basicConstraints, 1,
943                                             "\x30\x03\x01\x01\xff", 5);
944           if (err)
945             goto leave;
946           err = ksba_certreq_add_extension (cr, oidstr_standaloneCertificate, 0,
947                                             "\x01\x01\xff", 3);
948           if (err)
949             goto leave;
950         }
951
952       /* Store the creation date.  */
953       string = get_parameter_value (para, pNOTBEFORE, 0);
954       if (string)
955         {
956           if (!string2isotime (atime, string))
957             BUG (); /* We already checked the value.  */
958         }
959       else
960         gnupg_get_isotime (atime);
961       err = ksba_certreq_set_validity (cr, 0, atime);
962       if (err)
963         {
964           log_error ("error setting the creation date: %s\n",
965                      gpg_strerror (err));
966           goto leave;
967         }
968
969
970       /* Store the expire date.  If it is not given, libksba inserts a
971          default value.  */
972       string = get_parameter_value (para, pNOTAFTER, 0);
973       if (string)
974         {
975           if (!string2isotime (atime, string))
976             BUG (); /* We already checked the value.  */
977           err = ksba_certreq_set_validity (cr, 1, atime);
978           if (err)
979             {
980               log_error ("error setting the expire date: %s\n",
981                          gpg_strerror (err));
982               goto leave;
983             }
984         }
985
986
987       /* Figure out the signing algorithm.  If no sigkey has been
988          given we set it to the public key to create a self-signed
989          certificate. */
990       if (!sigkey)
991         sigkey = public;
992
993       {
994         unsigned char *siginfo;
995
996         err = transform_sigval (sigkey,
997                                 gcry_sexp_canon_len (sigkey, 0, NULL, NULL),
998                                 mdalgo, &siginfo, NULL);
999         if (!err)
1000           {
1001             err = ksba_certreq_set_siginfo (cr, siginfo);
1002             xfree (siginfo);
1003           }
1004         if (err)
1005           {
1006             log_error ("error setting the siginfo: %s\n",
1007                        gpg_strerror (err));
1008             rc = err;
1009             goto leave;
1010           }
1011       }
1012     }
1013   else
1014     sigkey = public;
1015
1016   do
1017     {
1018       err = ksba_certreq_build (cr, &stopreason);
1019       if (err)
1020         {
1021           log_error ("ksba_certreq_build failed: %s\n", gpg_strerror (err));
1022           rc = err;
1023           goto leave;
1024         }
1025       if (stopreason == KSBA_SR_NEED_SIG)
1026         {
1027           gcry_sexp_t s_pkey;
1028           size_t n;
1029           unsigned char grip[20];
1030           char hexgrip[41];
1031           unsigned char *sigval, *newsigval;
1032           size_t siglen;
1033
1034           n = gcry_sexp_canon_len (sigkey, 0, NULL, NULL);
1035           if (!n)
1036             {
1037               log_error ("libksba did not return a proper S-Exp\n");
1038               rc = gpg_error (GPG_ERR_BUG);
1039               goto leave;
1040             }
1041           rc = gcry_sexp_sscan (&s_pkey, NULL, (const char*)sigkey, n);
1042           if (rc)
1043             {
1044               log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
1045               goto leave;
1046             }
1047           if ( !gcry_pk_get_keygrip (s_pkey, grip) )
1048             {
1049               rc = gpg_error (GPG_ERR_GENERAL);
1050               log_error ("can't figure out the keygrip\n");
1051               gcry_sexp_release (s_pkey);
1052               goto leave;
1053             }
1054           gcry_sexp_release (s_pkey);
1055           bin2hex (grip, 20, hexgrip);
1056
1057           log_info ("about to sign the %s for key: &%s\n",
1058                     certmode? "certificate":"CSR", hexgrip);
1059
1060           if (carddirect)
1061             rc = gpgsm_scd_pksign (ctrl, carddirect, NULL,
1062                                    gcry_md_read (md, mdalgo),
1063                                    gcry_md_get_algo_dlen (mdalgo),
1064                                    mdalgo,
1065                                    &sigval, &siglen);
1066           else
1067             {
1068               char *orig_codeset;
1069               char *desc;
1070
1071               orig_codeset = i18n_switchto_utf8 ();
1072               desc = percent_plus_escape
1073                 (_("To complete this certificate request please enter"
1074                    " the passphrase for the key you just created once"
1075                    " more.\n"));
1076               i18n_switchback (orig_codeset);
1077               rc = gpgsm_agent_pksign (ctrl, hexgrip, desc,
1078                                        gcry_md_read(md, mdalgo),
1079                                        gcry_md_get_algo_dlen (mdalgo),
1080                                        mdalgo,
1081                                        &sigval, &siglen);
1082               xfree (desc);
1083             }
1084           if (rc)
1085             {
1086               log_error ("signing failed: %s\n", gpg_strerror (rc));
1087               goto leave;
1088             }
1089
1090           err = transform_sigval (sigval, siglen, mdalgo,
1091                                   &newsigval, NULL);
1092           xfree (sigval);
1093           if (!err)
1094             {
1095               err = ksba_certreq_set_sig_val (cr, newsigval);
1096               xfree (newsigval);
1097             }
1098           if (err)
1099             {
1100               log_error ("failed to store the sig_val: %s\n",
1101                          gpg_strerror (err));
1102               rc = err;
1103               goto leave;
1104             }
1105         }
1106     }
1107   while (stopreason != KSBA_SR_READY);
1108
1109
1110  leave:
1111   gcry_md_close (md);
1112   ksba_certreq_release (cr);
1113   return rc;
1114 }
1115
1116
1117 \f
1118 /* Create a new key by reading the parameters from IN_FP.  Multiple
1119    keys may be created */
1120 int
1121 gpgsm_genkey (ctrl_t ctrl, estream_t in_stream, estream_t out_stream)
1122 {
1123   int rc;
1124
1125   rc = read_parameters (ctrl, in_stream, out_stream);
1126   if (rc)
1127     {
1128       log_error ("error creating certificate request: %s <%s>\n",
1129                  gpg_strerror (rc), gpg_strsource (rc));
1130       goto leave;
1131     }
1132
1133  leave:
1134   return rc;
1135 }