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