* gpg-agent.c (handle_signal): Reload the trustlist on SIGHUP.
[gnupg.git] / sm / certreqgen.c
1 /* certreqgen.c - Generate a key and a certification request
2  *      Copyright (C) 2002, 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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         Do not write the certificate to the keyDB but to <filename>.
47         This must be given before the first
48         commit to take place, duplicate specification of the same filename
49         is ignored, the last filename before a commit is used.
50         The filename is used until a new filename is used (at commit points)
51         and all keys are written to that file.  If a new filename is given,
52         this file is created (and overwrites an existing one).
53         Both control statements must be given.
54    o The order of the parameters does not matter except for "Key-Type"
55      which must be the first parameter.  The parameters are only for the
56      generated keyblock and parameters from previous key generations are not
57      used. Some syntactically checks may be performed.
58      The currently defined parameters are:
59      Key-Type: <algo>
60         Starts a new parameter block by giving the type of the
61         primary key. The algorithm must be capable of signing.
62         This is a required parameter.  For now the only supported
63         algorithm is "rsa".
64      Key-Length: <length-in-bits>
65         Length of the key in bits.  Default is 1024.
66      Key-Usage: <usage-list>
67         Space or comma delimited list of key usage, allowed values are
68         "encrypt" and "sign".  This is used to generate the KeyUsage extension.
69         Please make sure that the algorithm is capable of this usage.  Default
70         is to allow encrypt and sign.
71      Name-DN: subject name
72         This is the DN name of the subject in rfc2253 format.
73      Name-Email: <string>
74         The ist the email address
75
76 Here is an example:
77 $ cat >foo <<EOF
78 %echo Generating a standard key
79 Key-Type: RSA
80 Key-Length: 1024
81 Name-DN: CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=Düsseldorf,C=DE
82 Name-Email: joe@foo.bar
83 # Do a commit here, so that we can later print "done" :-)
84 %commit
85 %echo done
86 EOF
87 */
88
89
90 #include <config.h>
91 #include <stdio.h>
92 #include <stdlib.h>
93 #include <string.h>
94 #include <errno.h>
95 #include <unistd.h> 
96 #include <time.h>
97 #include <assert.h>
98
99 #include "gpgsm.h"
100 #include <gcrypt.h>
101 #include <ksba.h>
102
103 #include "keydb.h"
104 #include "i18n.h"
105
106
107 enum para_name {
108   pKEYTYPE,
109   pKEYLENGTH,
110   pKEYUSAGE,
111   pNAMEDN,
112   pNAMEEMAIL
113 };
114
115 struct para_data_s {
116   struct para_data_s *next;
117   int lnr;
118   enum para_name key;
119   union {
120     unsigned int usage; 
121     char value[1];
122   } u;
123 };
124
125 struct reqgen_ctrl_s {
126   int lnr;
127   int dryrun;
128   ksba_writer_t writer;
129 };
130
131
132 static int proc_parameters (ctrl_t ctrl,
133                             struct para_data_s *para,
134                             struct reqgen_ctrl_s *outctrl);
135 static int create_request (ctrl_t ctrl,
136                            struct para_data_s *para,
137                            ksba_const_sexp_t public,
138                            struct reqgen_ctrl_s *outctrl);
139
140
141 \f
142 static void
143 release_parameter_list (struct para_data_s *r)
144 {
145   struct para_data_s *r2;
146   
147   for (; r ; r = r2)
148     {
149       r2 = r->next;
150       xfree(r);
151     }
152 }
153
154 static struct para_data_s *
155 get_parameter (struct para_data_s *para, enum para_name key)
156 {
157   struct para_data_s *r;
158   
159   for (r = para; r && r->key != key; r = r->next)
160     ;
161   return r;
162 }
163
164 static const char *
165 get_parameter_value (struct para_data_s *para, enum para_name key)
166 {
167   struct para_data_s *r = get_parameter (para, key);
168   return (r && *r->u.value)? r->u.value : NULL;
169 }
170
171 static int
172 get_parameter_algo (struct para_data_s *para, enum para_name key)
173 {
174   struct para_data_s *r = get_parameter (para, key);
175   if (!r)
176     return -1;
177   if (digitp (r->u.value))
178     return atoi( r->u.value );
179   return gcry_pk_map_name (r->u.value); 
180 }
181
182 /* parse the usage parameter.  Returns 0 on success.  Note that we
183    only care about sign and encrypt and don't (yet) allow all the
184    other X.509 usage to be specified; instead we will use a fixed
185    mapping to the X.509 usage flags */
186 static int
187 parse_parameter_usage (struct para_data_s *para, enum para_name key)
188 {
189   struct para_data_s *r = get_parameter (para, key);
190   char *p, *pn;
191   unsigned int use;
192   
193   if (!r)
194     return 0; /* none (this is an optional parameter)*/
195     
196   use = 0;
197   pn = r->u.value;
198   while ( (p = strsep (&pn, " \t,")) )
199     {
200       if (!*p)
201         ;
202       else if ( !ascii_strcasecmp (p, "sign") )
203         use |= GCRY_PK_USAGE_SIGN;
204       else if ( !ascii_strcasecmp (p, "encrypt") )
205         use |= GCRY_PK_USAGE_ENCR;
206       else
207         {
208           log_error ("line %d: invalid usage list\n", r->lnr);
209           return -1; /* error */
210         }
211     }
212   r->u.usage = use;
213   return 0;
214 }
215
216
217 static unsigned int
218 get_parameter_uint (struct para_data_s *para, enum para_name key)
219 {
220   struct para_data_s *r = get_parameter (para, key);
221
222   if (!r)
223     return 0;
224
225   return (unsigned int)strtoul (r->u.value, NULL, 10);
226 }
227
228
229
230 /* Read the certificate generation parameters from FP and generate
231    (all) certificate requests.  */
232 static int
233 read_parameters (ctrl_t ctrl, FILE *fp, ksba_writer_t writer)
234 {
235   static struct {
236     const char *name;
237     enum para_name key;
238   } keywords[] = {
239     { "Key-Type",       pKEYTYPE},
240     { "Key-Length",     pKEYLENGTH },
241     { "Key-Usage",      pKEYUSAGE },
242     { "Name-DN",        pNAMEDN },
243     { "Name-Email",     pNAMEEMAIL },
244     { NULL, 0 }
245   };
246   char line[1024], *p;
247   const char *err = NULL;
248   struct para_data_s *para, *r;
249   int i, rc = 0, any = 0;
250   struct reqgen_ctrl_s outctrl;
251
252   memset (&outctrl, 0, sizeof (outctrl));
253   outctrl.writer = writer;
254
255   err = NULL;
256   para = NULL;
257   while (fgets (line, DIM(line)-1, fp) )
258     {
259       char *keyword, *value;
260
261       outctrl.lnr++;
262       if (*line && line[strlen(line)-1] != '\n')
263         {
264           err = "line too long";
265           break;
266         }
267       for (p=line; spacep (p); p++)
268         ;
269       if (!*p || *p == '#')
270         continue;
271
272       keyword = p;
273       if (*keyword == '%')
274         {
275           for (; *p && !spacep (p); p++)
276             ;
277           if (*p)
278             *p++ = 0;
279           for (; spacep (p); p++)
280             ;
281           value = p;
282           trim_trailing_spaces (value);
283
284           if (!ascii_strcasecmp (keyword, "%echo"))
285             log_info ("%s\n", value);
286           else if (!ascii_strcasecmp (keyword, "%dry-run"))
287             outctrl.dryrun = 1;
288           else if (!ascii_strcasecmp( keyword, "%commit"))
289             {
290               rc = proc_parameters (ctrl, para, &outctrl);
291               if (rc)
292                 goto leave;
293               any = 1;
294               release_parameter_list (para);
295               para = NULL;
296             }
297           else
298             log_info ("skipping control `%s' (%s)\n", keyword, value);
299
300           continue;
301         }
302
303
304       if (!(p = strchr (p, ':')) || p == keyword)
305         {
306           err = "missing colon";
307           break;
308         }
309       if (*p)
310         *p++ = 0;
311       for (; spacep (p); p++)
312         ;
313       if (!*p)
314         {
315           err = "missing argument";
316           break;
317         }
318       value = p;
319       trim_trailing_spaces (value);
320
321       for (i=0; (keywords[i].name
322                  && ascii_strcasecmp (keywords[i].name, keyword)); i++)
323         ;
324       if (!keywords[i].name)
325         {
326           err = "unknown keyword";
327           break;
328         }
329       if (keywords[i].key != pKEYTYPE && !para)
330         {
331           err = "parameter block does not start with \"Key-Type\"";
332           break;
333         }
334
335       if (keywords[i].key == pKEYTYPE && para)
336         {
337           rc = proc_parameters (ctrl, para, &outctrl);
338           if (rc)
339             goto leave;
340           any = 1;
341           release_parameter_list (para);
342           para = NULL;
343         }
344       else
345         {
346           for (r = para; r && r->key != keywords[i].key; r = r->next)
347             ;
348           if (r)
349             {
350               err = "duplicate keyword";
351               break;
352             }
353         }
354
355       r = xtrycalloc (1, sizeof *r + strlen( value ));
356       if (!r)
357         {
358           err = "out of core";
359           break;
360         }
361       r->lnr = outctrl.lnr;
362       r->key = keywords[i].key;
363       strcpy (r->u.value, value);
364       r->next = para;
365       para = r;
366     }
367
368   if (err)
369     {
370       log_error ("line %d: %s\n", outctrl.lnr, err);
371       rc = gpg_error (GPG_ERR_GENERAL);
372     }
373   else if (ferror(fp))
374     {
375       log_error ("line %d: read error: %s\n", outctrl.lnr, strerror(errno) );
376       rc = gpg_error (GPG_ERR_GENERAL);
377     }
378   else if (para)
379     {
380       rc = proc_parameters (ctrl, para, &outctrl);
381       if (rc)
382         goto leave;
383       any = 1;
384     }
385
386   if (!rc && !any)
387     rc = gpg_error (GPG_ERR_NO_DATA);
388
389  leave:
390   release_parameter_list (para);
391   return rc;
392 }
393
394 /* check whether there are invalid characters in the email address S */
395 static int
396 has_invalid_email_chars (const char *s)
397 {
398   int at_seen=0;
399   static char valid_chars[] = "01234567890_-."
400                               "abcdefghijklmnopqrstuvwxyz"
401                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
402   for (; *s; s++)
403     {
404       if (*s & 0x80)
405         return 1;
406       if (*s == '@')
407         at_seen++;
408       else if (!at_seen && !( !!strchr (valid_chars, *s) || *s == '+'))
409         return 1;
410       else if (at_seen && !strchr (valid_chars, *s))
411         return 1;
412     }
413   return at_seen != 1;
414 }
415
416
417 /* Check that all required parameters are given and perform the action */
418 static int
419 proc_parameters (ctrl_t ctrl,
420                  struct para_data_s *para, struct reqgen_ctrl_s *outctrl)
421 {
422   struct para_data_s *r;
423   const char *s;
424   int i;
425   unsigned int nbits;
426   char numbuf[20];
427   unsigned char keyparms[100];
428   int rc;
429   ksba_sexp_t public;
430   
431   /* check that we have all required parameters */
432   assert (get_parameter (para, pKEYTYPE));
433
434   /* We can only use RSA for now.  There is a with pkcs-10 on how to
435      use ElGamal because it is expected that a PK algorithm can always
436      be used for signing. */
437   i = get_parameter_algo (para, pKEYTYPE);
438   if (i < 1 || i != GCRY_PK_RSA )
439     {
440       r = get_parameter (para, pKEYTYPE);
441       log_error ("line %d: invalid algorithm\n", r->lnr);
442       return gpg_error (GPG_ERR_INV_PARAMETER);
443     }
444   
445   /* check the keylength */
446   if (!get_parameter (para, pKEYLENGTH))
447     nbits = 1024;
448   else
449     nbits = get_parameter_uint (para, pKEYLENGTH);
450   if (nbits < 512 || nbits > 4096)
451     {
452       r = get_parameter (para, pKEYTYPE);
453       log_error ("line %d: invalid key length %u (valid are 512 to 4096)\n",
454                  r->lnr, nbits);
455       return gpg_error (GPG_ERR_INV_PARAMETER);
456     }
457     
458   /* check the usage */
459   if (parse_parameter_usage (para, pKEYUSAGE))
460     return gpg_error (GPG_ERR_INV_PARAMETER);
461
462   /* check that there is a subject name and that this DN fits our
463      requirements */
464   if (!(s=get_parameter_value (para, pNAMEDN)))
465     {
466       r = get_parameter (para, pKEYTYPE);
467       log_error ("line %d: no subject name given\n", r->lnr);
468       return gpg_error (GPG_ERR_INV_PARAMETER);
469     }
470   /* fixme check s */
471
472   /* check that the optional email address is okay */
473   if ((s=get_parameter_value (para, pNAMEEMAIL)))
474     { 
475       if (has_invalid_email_chars (s)
476           || *s == '@'
477           || s[strlen(s)-1] == '@'
478           || s[strlen(s)-1] == '.'
479           || strstr(s, ".."))
480         {
481           r = get_parameter (para, pKEYTYPE);
482           log_error ("line %d: not a valid email address\n", r->lnr);
483           return gpg_error (GPG_ERR_INV_PARAMETER);
484         }
485     }
486
487   sprintf (numbuf, "%u", nbits);
488   snprintf (keyparms, DIM (keyparms)-1, 
489             "(6:genkey(3:rsa(5:nbits%d:%s)))", strlen (numbuf), numbuf);
490   rc = gpgsm_agent_genkey (ctrl, keyparms, &public);
491   if (rc)
492     {
493       r = get_parameter (para, pKEYTYPE);
494       log_error ("line %d: key generation failed: %s\n",
495                  r->lnr, gpg_strerror (rc));
496       return rc;
497     }
498
499   rc = create_request (ctrl, para, public, outctrl);
500   xfree (public);
501
502   return rc;
503 }
504
505
506 /* Parameters are checked, the key pair has been created.  Now
507    generate the request and write it out */
508 static int
509 create_request (ctrl_t ctrl,
510                 struct para_data_s *para, ksba_const_sexp_t public,
511                 struct reqgen_ctrl_s *outctrl)
512 {
513   ksba_certreq_t cr;
514   gpg_error_t err;
515   gcry_md_hd_t md;
516   ksba_stop_reason_t stopreason;
517   int rc = 0;
518   const char *s;
519
520   err = ksba_certreq_new (&cr);
521   if (err)
522     return err;
523
524   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0);
525   if (rc)
526     {
527       log_error ("md_open failed: %s\n", gpg_strerror (rc));
528       goto leave;
529     }
530   if (DBG_HASHING)
531     gcry_md_start_debug (md, "cr.cri");
532
533   ksba_certreq_set_hash_function (cr, HASH_FNC, md);
534   ksba_certreq_set_writer (cr, outctrl->writer);
535   
536   err = ksba_certreq_add_subject (cr, get_parameter_value (para, pNAMEDN));
537   if (err)
538     {
539       log_error ("error setting the subject's name: %s\n",
540                  gpg_strerror (err));
541       rc = err;
542       goto leave;
543     }
544
545   s = get_parameter_value (para, pNAMEEMAIL);
546   if (s)
547     {
548       char *buf;
549
550       buf = xtrymalloc (strlen (s) + 3);
551       if (!buf)
552         {
553           rc = OUT_OF_CORE (errno);
554           goto leave;
555         }
556       *buf = '<';
557       strcpy (buf+1, s);
558       strcat (buf+1, ">");
559       err = ksba_certreq_add_subject (cr, buf);
560       xfree (buf);
561       if (err)
562         {
563           log_error ("error setting the subject's alternate name: %s\n",
564                      gpg_strerror (err));
565           rc = err;
566           goto leave;
567         }
568     }
569
570
571   err = ksba_certreq_set_public_key (cr, public);
572   if (err)
573     {
574       log_error ("error setting the public key: %s\n",
575                  gpg_strerror (err));
576       rc = err;
577       goto leave;
578     }
579                
580   do
581     {
582       err = ksba_certreq_build (cr, &stopreason);
583       if (err)
584         {
585           log_error ("ksba_certreq_build failed: %s\n", gpg_strerror (err));
586           rc = err;
587           goto leave;
588         }
589       if (stopreason == KSBA_SR_NEED_SIG)
590         {
591           gcry_sexp_t s_pkey;
592           size_t n;
593           unsigned char grip[20], hexgrip[41];
594           char *sigval;
595           size_t siglen;
596
597           n = gcry_sexp_canon_len (public, 0, NULL, NULL);
598           if (!n)
599             {
600               log_error ("libksba did not return a proper S-Exp\n");
601               err = gpg_error (GPG_ERR_BUG);
602               goto leave;
603             }
604           rc = gcry_sexp_sscan (&s_pkey, NULL, public, n);
605           if (rc)
606             {
607               log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
608               goto leave;
609             }
610           if ( !gcry_pk_get_keygrip (s_pkey, grip) )
611             {
612               rc = gpg_error (GPG_ERR_GENERAL);
613               log_error ("can't figure out the keygrip\n");
614               gcry_sexp_release (s_pkey);
615               goto leave;
616             }
617           gcry_sexp_release (s_pkey);
618           for (n=0; n < 20; n++)
619             sprintf (hexgrip+n*2, "%02X", grip[n]);
620
621           rc = gpgsm_agent_pksign (ctrl, hexgrip, NULL,
622                                    gcry_md_read(md, GCRY_MD_SHA1), 
623                                    gcry_md_get_algo_dlen (GCRY_MD_SHA1),
624                                    GCRY_MD_SHA1,
625                                    &sigval, &siglen);
626           if (rc)
627             {
628               log_error ("signing failed: %s\n", gpg_strerror (rc));
629               goto leave;
630             }
631           
632           err = ksba_certreq_set_sig_val (cr, sigval);
633           xfree (sigval);
634           if (err)
635             {
636               log_error ("failed to store the sig_val: %s\n",
637                          gpg_strerror (err));
638               rc = err;
639               goto leave;
640             }
641         }
642     }
643   while (stopreason != KSBA_SR_READY);   
644   
645
646  leave:
647   gcry_md_close (md);
648   ksba_certreq_release (cr);
649   return rc;  
650 }
651
652
653 \f
654 /* Create a new key by reading the parameters from in_fd.  Multiple
655    keys may be created */
656 int
657 gpgsm_genkey (ctrl_t ctrl, int in_fd, FILE *out_fp)
658 {
659   int rc;
660   FILE *in_fp;
661   Base64Context b64writer = NULL;
662   ksba_writer_t writer;
663
664   in_fp = fdopen (dup (in_fd), "rb");
665   if (!in_fp)
666     {
667       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
668       log_error ("fdopen() failed: %s\n", strerror (errno));
669       return tmperr;
670     }
671
672   ctrl->pem_name = "NEW CERTIFICATE REQUEST";
673   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
674   if (rc)
675     {
676       log_error ("can't create writer: %s\n", gpg_strerror (rc));
677       goto leave;
678     }
679
680   rc = read_parameters (ctrl, in_fp, writer);
681   if (rc)
682     {
683       log_error ("error creating certificate request: %s\n",
684                  gpg_strerror (rc));
685       goto leave;
686     }
687
688   rc = gpgsm_finish_writer (b64writer);
689   if (rc) 
690     {
691       log_error ("write failed: %s\n", gpg_strerror (rc));
692       goto leave;
693     }
694
695   gpgsm_status (ctrl, STATUS_KEY_CREATED, "P");
696   log_info ("certificate request created\n");
697
698  leave:
699   gpgsm_destroy_writer (b64writer);
700   fclose (in_fp);
701   return rc;
702 }
703