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