speedo,w32: Install gpg-wks-client.
[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: 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     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 = 2048;
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   string = get_parameter_value (para, pHASHALGO, 0);
811   if (string)
812     mdalgo = gcry_md_map_name (string);
813   else
814     mdalgo = GCRY_MD_SHA256;
815   rc = gcry_md_open (&md, mdalgo, 0);
816   if (rc)
817     {
818       log_error ("md_open failed: %s\n", gpg_strerror (rc));
819       goto leave;
820     }
821   if (DBG_HASHING)
822     gcry_md_debug (md, "cr.cri");
823
824   ksba_certreq_set_hash_function (cr, HASH_FNC, md);
825   ksba_certreq_set_writer (cr, writer);
826
827   err = ksba_certreq_add_subject (cr, get_parameter_value (para, pNAMEDN, 0));
828   if (err)
829     {
830       log_error ("error setting the subject's name: %s\n",
831                  gpg_strerror (err));
832       rc = err;
833       goto leave;
834     }
835
836   for (seq=0; (s = get_parameter_value (para, pNAMEEMAIL, seq)); seq++)
837     {
838       buf = xtrymalloc (strlen (s) + 3);
839       if (!buf)
840         {
841           rc = out_of_core ();
842           goto leave;
843         }
844       *buf = '<';
845       strcpy (buf+1, s);
846       strcat (buf+1, ">");
847       err = ksba_certreq_add_subject (cr, buf);
848       xfree (buf);
849       if (err)
850         {
851           log_error ("error setting the subject's alternate name: %s\n",
852                      gpg_strerror (err));
853           rc = err;
854           goto leave;
855         }
856     }
857
858   for (seq=0; (s = get_parameter_value (para, pNAMEDNS, seq)); seq++)
859     {
860       len = strlen (s);
861       assert (len);
862       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
863       buf = p = xtrymalloc (11 + strlen (numbuf) + len + 3);
864       if (!buf)
865         {
866           rc = out_of_core ();
867           goto leave;
868         }
869       p = stpcpy (p, "(8:dns-name");
870       p = stpcpy (p, numbuf);
871       p = stpcpy (p, s);
872       strcpy (p, ")");
873
874       err = ksba_certreq_add_subject (cr, buf);
875       xfree (buf);
876       if (err)
877         {
878           log_error ("error setting the subject's alternate name: %s\n",
879                      gpg_strerror (err));
880           rc = err;
881           goto leave;
882         }
883     }
884
885   for (seq=0; (s = get_parameter_value (para, pNAMEURI, seq)); seq++)
886     {
887       len = strlen (s);
888       assert (len);
889       snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
890       buf = p = xtrymalloc (6 + strlen (numbuf) + len + 3);
891       if (!buf)
892         {
893           rc = out_of_core ();
894           goto leave;
895         }
896       p = stpcpy (p, "(3:uri");
897       p = stpcpy (p, numbuf);
898       p = stpcpy (p, s);
899       strcpy (p, ")");
900
901       err = ksba_certreq_add_subject (cr, buf);
902       xfree (buf);
903       if (err)
904         {
905           log_error ("error setting the subject's alternate name: %s\n",
906                      gpg_strerror (err));
907           rc = err;
908           goto leave;
909         }
910     }
911
912
913   err = ksba_certreq_set_public_key (cr, public);
914   if (err)
915     {
916       log_error ("error setting the public key: %s\n",
917                  gpg_strerror (err));
918       rc = err;
919       goto leave;
920     }
921
922   /* Set key usage flags.  */
923   use = get_parameter_uint (para, pKEYUSAGE);
924   if (use)
925     {
926       unsigned int mask, pos;
927       unsigned char der[4];
928
929       der[0] = 0x03;
930       der[1] = 0x02;
931       der[2] = 0;
932       der[3] = 0;
933       if ((use & GCRY_PK_USAGE_SIGN))
934         {
935           /* For signing only we encode the bits:
936              KSBA_KEYUSAGE_DIGITAL_SIGNATURE
937              KSBA_KEYUSAGE_NON_REPUDIATION  = 0b11 -> 0b11000000 */
938           der[3] |= 0xc0;
939         }
940       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 = 0b1100 -> 0b00110000 */
945           der[3] |= 0x30;
946         }
947       if ((use & GCRY_PK_USAGE_CERT))
948         {
949           /* For certify only we encode the bits:
950              KSBA_KEYUSAGE_KEY_CERT_SIGN
951              KSBA_KEYUSAGE_CRL_SIGN      = 0b1100000 -> 0b00000110 */
952           der[3] |= 0x06;
953         }
954
955       /* Count number of unused bits.  */
956       for (mask=1, pos=0; pos < 8 * sizeof mask; pos++, mask <<= 1)
957         {
958           if ((der[3] & mask))
959             break;
960           der[2]++;
961         }
962
963       err = ksba_certreq_add_extension (cr, oidstr_keyUsage, 1, der, 4);
964       if (err)
965         {
966           log_error ("error setting the key usage: %s\n",
967                      gpg_strerror (err));
968           rc = err;
969           goto leave;
970         }
971     }
972
973
974   /* See whether we want to create an X.509 certificate.  */
975   string = get_parameter_value (para, pSERIAL, 0);
976   if (string)
977     {
978       certmode = 1;
979
980       /* Store the serial number.  */
981       if (!strcmp (string, "random"))
982         {
983           char snbuf[3+8+1];
984
985           memcpy (snbuf, "(8:", 3);
986           gcry_create_nonce (snbuf+3, 8);
987           /* Clear high bit to guarantee a positive integer.  */
988           snbuf[3] &= 0x7f;
989           snbuf[3+8] = ')';
990           err = ksba_certreq_set_serial (cr, snbuf);
991         }
992       else
993         {
994           char *hexbuf;
995
996           /* Allocate a buffer large enough to prefix the string with
997              a '0' so to have an even number of digits.  Prepend two
998              further '0' so that the binary result will have a leading
999              0 byte and thus can't be the representation of a negative
1000              number.  Note that ksba_certreq_set_serial strips all
1001              unneeded leading 0 bytes.  */
1002           hexbuf = p = xtrymalloc (2 + 1 + strlen (string) + 1);
1003           if (!hexbuf)
1004             {
1005               err = gpg_error_from_syserror ();
1006               goto leave;
1007             }
1008           if ((strlen (string) & 1))
1009             *p++ = '0';
1010           *p++ = '0';
1011           *p++ = '0';
1012           strcpy (p, string);
1013           for (p=hexbuf, len=0; p[0] && p[1]; p += 2)
1014             ((unsigned char*)hexbuf)[len++] = xtoi_2 (p);
1015           /* Now build the S-expression.  */
1016           snprintf (numbuf, DIM(numbuf), "%u:", (unsigned int)len);
1017           buf = p = xtrymalloc (1 + strlen (numbuf) + len + 1 + 1);
1018           if (!buf)
1019             {
1020               err = gpg_error_from_syserror ();
1021               xfree (hexbuf);
1022               goto leave;
1023             }
1024           p = stpcpy (stpcpy (buf, "("), numbuf);
1025           memcpy (p, hexbuf, len);
1026           p += len;
1027           strcpy (p, ")");
1028           xfree (hexbuf);
1029           err = ksba_certreq_set_serial (cr, buf);
1030           xfree (buf);
1031         }
1032       if (err)
1033         {
1034           log_error ("error setting the serial number: %s\n",
1035                      gpg_strerror (err));
1036           goto leave;
1037         }
1038
1039
1040       /* Store the issuer DN.  If no issuer DN is given and no signing
1041          key has been set we add the standalone extension and the
1042          basic constraints to mark it as a self-signed CA
1043          certificate.  */
1044       string = get_parameter_value (para, pISSUERDN, 0);
1045       if (string)
1046         {
1047           /* Issuer DN given.  Note that this may be the same as the
1048              subject DN and thus this could as well be a self-signed
1049              certificate.  However the caller needs to explicitly
1050              specify basicConstraints and so forth.  */
1051           err = ksba_certreq_set_issuer (cr, string);
1052           if (err)
1053             {
1054               log_error ("error setting the issuer DN: %s\n",
1055                          gpg_strerror (err));
1056               goto leave;
1057             }
1058
1059         }
1060       else if (!string && !sigkey)
1061         {
1062           /* Self-signed certificate requested.  Add basicConstraints
1063              and the custom GnuPG standalone extension.  */
1064           err = ksba_certreq_add_extension (cr, oidstr_basicConstraints, 1,
1065                                             "\x30\x03\x01\x01\xff", 5);
1066           if (err)
1067             goto leave;
1068           err = ksba_certreq_add_extension (cr, oidstr_standaloneCertificate, 0,
1069                                             "\x01\x01\xff", 3);
1070           if (err)
1071             goto leave;
1072         }
1073
1074       /* Store the creation date.  */
1075       string = get_parameter_value (para, pNOTBEFORE, 0);
1076       if (string)
1077         {
1078           if (!string2isotime (atime, string))
1079             BUG (); /* We already checked the value.  */
1080         }
1081       else
1082         gnupg_get_isotime (atime);
1083       err = ksba_certreq_set_validity (cr, 0, atime);
1084       if (err)
1085         {
1086           log_error ("error setting the creation date: %s\n",
1087                      gpg_strerror (err));
1088           goto leave;
1089         }
1090
1091
1092       /* Store the expire date.  If it is not given, libksba inserts a
1093          default value.  */
1094       string = get_parameter_value (para, pNOTAFTER, 0);
1095       if (string)
1096         {
1097           if (!string2isotime (atime, string))
1098             BUG (); /* We already checked the value.  */
1099           err = ksba_certreq_set_validity (cr, 1, atime);
1100           if (err)
1101             {
1102               log_error ("error setting the expire date: %s\n",
1103                          gpg_strerror (err));
1104               goto leave;
1105             }
1106         }
1107
1108
1109       /* Figure out the signing algorithm.  If no sigkey has been
1110          given we set it to the public key to create a self-signed
1111          certificate. */
1112       if (!sigkey)
1113         sigkey = public;
1114
1115       {
1116         unsigned char *siginfo;
1117
1118         err = transform_sigval (sigkey,
1119                                 gcry_sexp_canon_len (sigkey, 0, NULL, NULL),
1120                                 mdalgo, &siginfo, NULL);
1121         if (!err)
1122           {
1123             err = ksba_certreq_set_siginfo (cr, siginfo);
1124             xfree (siginfo);
1125           }
1126         if (err)
1127           {
1128             log_error ("error setting the siginfo: %s\n",
1129                        gpg_strerror (err));
1130             rc = err;
1131             goto leave;
1132           }
1133       }
1134
1135       /* Insert the AuthorityKeyId.  */
1136       string = get_parameter_value (para, pAUTHKEYID, 0);
1137       if (string)
1138         {
1139           char *hexbuf;
1140
1141           /* Allocate a buffer for in-place conversion.  We also add 4
1142              extra bytes space for the tags and lengths fields.  */
1143           hexbuf = xtrymalloc (4 + strlen (string) + 1);
1144           if (!hexbuf)
1145             {
1146               err = gpg_error_from_syserror ();
1147               goto leave;
1148             }
1149           strcpy (hexbuf+4, string);
1150           for (p=hexbuf+4, len=0; p[0] && p[1]; p += 2)
1151             ((unsigned char*)hexbuf)[4+len++] = xtoi_2 (p);
1152           if (len > 125)
1153             {
1154               err = gpg_error (GPG_ERR_TOO_LARGE);
1155               xfree (hexbuf);
1156               goto leave;
1157             }
1158           hexbuf[0] = 0x30;  /* Tag for a Sequence.  */
1159           hexbuf[1] = len+2;
1160           hexbuf[2] = 0x80;  /* Context tag for an implicit Octet string.  */
1161           hexbuf[3] = len;
1162           err = ksba_certreq_add_extension (cr, oidstr_authorityKeyIdentifier,
1163                                             0,
1164                                             hexbuf, 4+len);
1165           xfree (hexbuf);
1166           if (err)
1167             {
1168               log_error ("error setting the authority-key-id: %s\n",
1169                          gpg_strerror (err));
1170               goto leave;
1171             }
1172         }
1173
1174       /* Insert the SubjectKeyId.  */
1175       string = get_parameter_value (para, pSUBJKEYID, 0);
1176       if (string)
1177         {
1178           char *hexbuf;
1179
1180           /* Allocate a buffer for in-place conversion.  We also add 2
1181              extra bytes space for the tag and length field.  */
1182           hexbuf = xtrymalloc (2 + strlen (string) + 1);
1183           if (!hexbuf)
1184             {
1185               err = gpg_error_from_syserror ();
1186               goto leave;
1187             }
1188           strcpy (hexbuf+2, string);
1189           for (p=hexbuf+2, len=0; p[0] && p[1]; p += 2)
1190             ((unsigned char*)hexbuf)[2+len++] = xtoi_2 (p);
1191           if (len > 127)
1192             {
1193               err = gpg_error (GPG_ERR_TOO_LARGE);
1194               xfree (hexbuf);
1195               goto leave;
1196             }
1197           hexbuf[0] = 0x04;  /* Tag for an Octet string.  */
1198           hexbuf[1] = len;
1199           err = ksba_certreq_add_extension (cr, oidstr_subjectKeyIdentifier, 0,
1200                                             hexbuf, 2+len);
1201           xfree (hexbuf);
1202           if (err)
1203             {
1204               log_error ("error setting the subject-key-id: %s\n",
1205                          gpg_strerror (err));
1206               goto leave;
1207             }
1208         }
1209
1210       /* Insert additional extensions.  */
1211       for (seq=0; (string = get_parameter_value (para, pEXTENSION, seq)); seq++)
1212         {
1213           char *hexbuf;
1214           char *oidstr;
1215           int crit = 0;
1216
1217           s = strpbrk (string, " \t:");
1218           if (!s)
1219             {
1220               err = gpg_error (GPG_ERR_INTERNAL);
1221               goto leave;
1222             }
1223
1224           oidstr = xtrymalloc (s - string + 1);
1225           if (!oidstr)
1226             {
1227               err = gpg_error_from_syserror ();
1228               goto leave;
1229             }
1230           memcpy (oidstr, string, (s-string));
1231           oidstr[(s-string)] = 0;
1232
1233           s++;
1234           while (spacep (s))
1235             s++;
1236           if (!*s)
1237             {
1238               err = gpg_error (GPG_ERR_INTERNAL);
1239               xfree (oidstr);
1240               goto leave;
1241             }
1242
1243           if (strchr ("cC", *s))
1244             crit = 1;
1245           s++;
1246           while (spacep (s))
1247             s++;
1248           if (*s == ':')
1249             s++;
1250           while (spacep (s))
1251             s++;
1252
1253           hexbuf = xtrystrdup (s);
1254           if (!hexbuf)
1255             {
1256               err = gpg_error_from_syserror ();
1257               xfree (oidstr);
1258               goto leave;
1259             }
1260           for (p=hexbuf, len=0; p[0] && p[1]; p += 2)
1261             ((unsigned char*)hexbuf)[len++] = xtoi_2 (p);
1262           err = ksba_certreq_add_extension (cr, oidstr, crit,
1263                                             hexbuf, len);
1264           xfree (oidstr);
1265           xfree (hexbuf);
1266         }
1267     }
1268   else
1269     sigkey = public;
1270
1271   do
1272     {
1273       err = ksba_certreq_build (cr, &stopreason);
1274       if (err)
1275         {
1276           log_error ("ksba_certreq_build failed: %s\n", gpg_strerror (err));
1277           rc = err;
1278           goto leave;
1279         }
1280       if (stopreason == KSBA_SR_NEED_SIG)
1281         {
1282           gcry_sexp_t s_pkey;
1283           size_t n;
1284           unsigned char grip[20];
1285           char hexgrip[41];
1286           unsigned char *sigval, *newsigval;
1287           size_t siglen;
1288
1289           n = gcry_sexp_canon_len (sigkey, 0, NULL, NULL);
1290           if (!n)
1291             {
1292               log_error ("libksba did not return a proper S-Exp\n");
1293               rc = gpg_error (GPG_ERR_BUG);
1294               goto leave;
1295             }
1296           rc = gcry_sexp_sscan (&s_pkey, NULL, (const char*)sigkey, n);
1297           if (rc)
1298             {
1299               log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
1300               goto leave;
1301             }
1302           if ( !gcry_pk_get_keygrip (s_pkey, grip) )
1303             {
1304               rc = gpg_error (GPG_ERR_GENERAL);
1305               log_error ("can't figure out the keygrip\n");
1306               gcry_sexp_release (s_pkey);
1307               goto leave;
1308             }
1309           gcry_sexp_release (s_pkey);
1310           bin2hex (grip, 20, hexgrip);
1311
1312           log_info ("about to sign the %s for key: &%s\n",
1313                     certmode? "certificate":"CSR", hexgrip);
1314
1315           if (carddirect)
1316             rc = gpgsm_scd_pksign (ctrl, carddirect, NULL,
1317                                    gcry_md_read (md, mdalgo),
1318                                    gcry_md_get_algo_dlen (mdalgo),
1319                                    mdalgo,
1320                                    &sigval, &siglen);
1321           else
1322             {
1323               char *orig_codeset;
1324               char *desc;
1325
1326               orig_codeset = i18n_switchto_utf8 ();
1327               desc = percent_plus_escape
1328                 (_("To complete this certificate request please enter"
1329                    " the passphrase for the key you just created once"
1330                    " more.\n"));
1331               i18n_switchback (orig_codeset);
1332               rc = gpgsm_agent_pksign (ctrl, hexgrip, desc,
1333                                        gcry_md_read(md, mdalgo),
1334                                        gcry_md_get_algo_dlen (mdalgo),
1335                                        mdalgo,
1336                                        &sigval, &siglen);
1337               xfree (desc);
1338             }
1339           if (rc)
1340             {
1341               log_error ("signing failed: %s\n", gpg_strerror (rc));
1342               goto leave;
1343             }
1344
1345           err = transform_sigval (sigval, siglen, mdalgo,
1346                                   &newsigval, NULL);
1347           xfree (sigval);
1348           if (!err)
1349             {
1350               err = ksba_certreq_set_sig_val (cr, newsigval);
1351               xfree (newsigval);
1352             }
1353           if (err)
1354             {
1355               log_error ("failed to store the sig_val: %s\n",
1356                          gpg_strerror (err));
1357               rc = err;
1358               goto leave;
1359             }
1360         }
1361     }
1362   while (stopreason != KSBA_SR_READY);
1363
1364
1365  leave:
1366   gcry_md_close (md);
1367   ksba_certreq_release (cr);
1368   return rc;
1369 }
1370
1371
1372 \f
1373 /* Create a new key by reading the parameters from IN_FP.  Multiple
1374    keys may be created */
1375 int
1376 gpgsm_genkey (ctrl_t ctrl, estream_t in_stream, estream_t out_stream)
1377 {
1378   int rc;
1379
1380   rc = read_parameters (ctrl, in_stream, out_stream);
1381   if (rc)
1382     {
1383       log_error ("error creating certificate request: %s <%s>\n",
1384                  gpg_strerror (rc), gpg_strsource (rc));
1385       goto leave;
1386     }
1387
1388  leave:
1389   return rc;
1390 }