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