Merge branch 'STABLE-BRANCH-2-2' into master
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - Generate a key pair
2  * Copyright (C) 1998-2007, 2009-2011  Free Software Foundation, Inc.
3  * Copyright (C) 2014, 2015, 2016  Werner Koch
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 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30
31 #include "gpg.h"
32 #include "../common/util.h"
33 #include "main.h"
34 #include "packet.h"
35 #include "../common/ttyio.h"
36 #include "options.h"
37 #include "keydb.h"
38 #include "trustdb.h"
39 #include "../common/status.h"
40 #include "../common/i18n.h"
41 #include "keyserver-internal.h"
42 #include "call-agent.h"
43 #include "pkglue.h"
44 #include "../common/shareddefs.h"
45 #include "../common/host2net.h"
46 #include "../common/mbox-util.h"
47
48
49 /* The default algorithms.  If you change them, you should ensure the value
50    is inside the bounds enforced by ask_keysize and gen_xxx.  See also
51    get_keysize_range which encodes the allowed ranges.  */
52 #define DEFAULT_STD_KEY_PARAM  "rsa3072/cert,sign+rsa3072/encr"
53 #define FUTURE_STD_KEY_PARAM   "ed25519/cert,sign+cv25519/encr"
54
55 /* When generating keys using the streamlined key generation dialog,
56    use this as a default expiration interval.  */
57 const char *default_expiration_interval = "2y";
58
59 /* Flag bits used during key generation.  */
60 #define KEYGEN_FLAG_NO_PROTECTION 1
61 #define KEYGEN_FLAG_TRANSIENT_KEY 2
62
63 /* Maximum number of supported algorithm preferences.  */
64 #define MAX_PREFS 30
65
66 enum para_name {
67   pKEYTYPE,
68   pKEYLENGTH,
69   pKEYCURVE,
70   pKEYUSAGE,
71   pSUBKEYTYPE,
72   pSUBKEYLENGTH,
73   pSUBKEYCURVE,
74   pSUBKEYUSAGE,
75   pAUTHKEYTYPE,
76   pNAMEREAL,
77   pNAMEEMAIL,
78   pNAMECOMMENT,
79   pPREFERENCES,
80   pREVOKER,
81   pUSERID,
82   pCREATIONDATE,
83   pKEYCREATIONDATE, /* Same in seconds since epoch.  */
84   pEXPIREDATE,
85   pKEYEXPIRE, /* in n seconds */
86   pSUBKEYEXPIRE, /* in n seconds */
87   pPASSPHRASE,
88   pSERIALNO,
89   pCARDBACKUPKEY,
90   pHANDLE,
91   pKEYSERVER,
92   pKEYGRIP,
93   pSUBKEYGRIP
94 };
95
96 struct para_data_s {
97     struct para_data_s *next;
98     int lnr;
99     enum para_name key;
100     union {
101         u32 expire;
102         u32 creation;
103         unsigned int usage;
104         struct revocation_key revkey;
105         char value[1];
106     } u;
107 };
108
109 struct output_control_s
110 {
111   int lnr;
112   int dryrun;
113   unsigned int keygen_flags;
114   int use_files;
115   struct {
116     char  *fname;
117     char  *newfname;
118     IOBUF stream;
119     armor_filter_context_t *afx;
120   } pub;
121 };
122
123
124 struct opaque_data_usage_and_pk {
125     unsigned int usage;
126     PKT_public_key *pk;
127 };
128
129
130 static int prefs_initialized = 0;
131 static byte sym_prefs[MAX_PREFS];
132 static int nsym_prefs;
133 static byte hash_prefs[MAX_PREFS];
134 static int nhash_prefs;
135 static byte zip_prefs[MAX_PREFS];
136 static int nzip_prefs;
137 static int mdc_available,ks_modify;
138
139 static gpg_error_t parse_algo_usage_expire (ctrl_t ctrl, int for_subkey,
140                                      const char *algostr, const char *usagestr,
141                                      const char *expirestr,
142                                      int *r_algo, unsigned int *r_usage,
143                                      u32 *r_expire,
144                                      unsigned int *r_nbits, char **r_curve);
145 static void do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
146                                  struct output_control_s *outctrl, int card );
147 static int write_keyblock (iobuf_t out, kbnode_t node);
148 static gpg_error_t gen_card_key (int keyno, int algo, int is_primary,
149                                  kbnode_t pub_root, u32 *timestamp,
150                                  u32 expireval);
151 static unsigned int get_keysize_range (int algo,
152                                        unsigned int *min, unsigned int *max);
153
154
155 \f
156 /* Return the algo string for a default new key.  */
157 const char *
158 get_default_pubkey_algo (void)
159 {
160   if (opt.def_new_key_algo)
161     {
162       if (*opt.def_new_key_algo && !strchr (opt.def_new_key_algo, ':'))
163         return opt.def_new_key_algo;
164       /* To avoid checking that option every time we delay that until
165        * here.  The only thing we really need to make sure is that
166        * there is no colon in the string so that the --gpgconf-list
167        * command won't mess up its output.  */
168       log_info (_("invalid value for option '%s'\n"), "--default-new-key-algo");
169     }
170   return DEFAULT_STD_KEY_PARAM;
171 }
172
173
174 static void
175 print_status_key_created (int letter, PKT_public_key *pk, const char *handle)
176 {
177   byte array[MAX_FINGERPRINT_LEN], *s;
178   char *buf, *p;
179   size_t i, n;
180
181   if (!handle)
182     handle = "";
183
184   buf = xmalloc (MAX_FINGERPRINT_LEN*2+31 + strlen (handle) + 1);
185
186   p = buf;
187   if (letter || pk)
188     {
189       *p++ = letter;
190       if (pk)
191         {
192           *p++ = ' ';
193           fingerprint_from_pk (pk, array, &n);
194           s = array;
195           /* Fixme: Use bin2hex */
196           for (i=0; i < n ; i++, s++, p += 2)
197             snprintf (p, 3, "%02X", *s);
198         }
199     }
200   if (*handle)
201     {
202       *p++ = ' ';
203       for (i=0; handle[i] && i < 100; i++)
204         *p++ = isspace ((unsigned int)handle[i])? '_':handle[i];
205     }
206   *p = 0;
207   write_status_text ((letter || pk)?STATUS_KEY_CREATED:STATUS_KEY_NOT_CREATED,
208                      buf);
209   xfree (buf);
210 }
211
212 static void
213 print_status_key_not_created (const char *handle)
214 {
215   print_status_key_created (0, NULL, handle);
216 }
217
218
219
220 static void
221 write_uid( KBNODE root, const char *s )
222 {
223     PACKET *pkt = xmalloc_clear(sizeof *pkt );
224     size_t n = strlen(s);
225
226     pkt->pkttype = PKT_USER_ID;
227     pkt->pkt.user_id = xmalloc_clear (sizeof *pkt->pkt.user_id + n);
228     pkt->pkt.user_id->len = n;
229     pkt->pkt.user_id->ref = 1;
230     strcpy(pkt->pkt.user_id->name, s);
231     add_kbnode( root, new_kbnode( pkt ) );
232 }
233
234 static void
235 do_add_key_flags (PKT_signature *sig, unsigned int use)
236 {
237     byte buf[1];
238
239     buf[0] = 0;
240
241     /* The spec says that all primary keys MUST be able to certify. */
242     if(sig->sig_class!=0x18)
243       buf[0] |= 0x01;
244
245     if (use & PUBKEY_USAGE_SIG)
246       buf[0] |= 0x02;
247     if (use & PUBKEY_USAGE_ENC)
248         buf[0] |= 0x04 | 0x08;
249     if (use & PUBKEY_USAGE_AUTH)
250         buf[0] |= 0x20;
251
252     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
253 }
254
255
256 int
257 keygen_add_key_expire (PKT_signature *sig, void *opaque)
258 {
259   PKT_public_key *pk = opaque;
260   byte buf[8];
261   u32  u;
262
263   if (pk->expiredate)
264     {
265       if (pk->expiredate > pk->timestamp)
266         u = pk->expiredate - pk->timestamp;
267       else
268         u = 1;
269
270       buf[0] = (u >> 24) & 0xff;
271       buf[1] = (u >> 16) & 0xff;
272       buf[2] = (u >>  8) & 0xff;
273       buf[3] = u & 0xff;
274       build_sig_subpkt (sig, SIGSUBPKT_KEY_EXPIRE, buf, 4);
275     }
276   else
277     {
278       /* Make sure we don't leave a key expiration subpacket lying
279          around */
280       delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
281     }
282
283   return 0;
284 }
285
286
287 /* Add the key usage (i.e. key flags) in SIG from the public keys
288  * pubkey_usage field.  OPAQUE has the public key.  */
289 int
290 keygen_add_key_flags (PKT_signature *sig, void *opaque)
291 {
292   PKT_public_key *pk = opaque;
293
294   do_add_key_flags (sig, pk->pubkey_usage);
295   return 0;
296 }
297
298
299 static int
300 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
301 {
302   struct opaque_data_usage_and_pk *oduap = opaque;
303
304   do_add_key_flags (sig, oduap->usage);
305   return keygen_add_key_expire (sig, oduap->pk);
306 }
307
308
309 static int
310 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
311 {
312     int i;
313
314     for (i=0; i < *nbuf; i++ )
315       if (buf[i] == val)
316         {
317           log_info (_("preference '%s' duplicated\n"), item);
318           return -1;
319         }
320
321     if (*nbuf >= MAX_PREFS)
322       {
323         if(type==1)
324           log_info(_("too many cipher preferences\n"));
325         else if(type==2)
326           log_info(_("too many digest preferences\n"));
327         else if(type==3)
328           log_info(_("too many compression preferences\n"));
329         else
330           BUG();
331
332         return -1;
333       }
334
335     buf[(*nbuf)++] = val;
336     return 0;
337 }
338
339 /*
340  * Parse the supplied string and use it to set the standard
341  * preferences.  The string may be in a form like the one printed by
342  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
343  * cipher/hash/compress names.  Use NULL to set the default
344  * preferences.  Returns: 0 = okay
345  */
346 int
347 keygen_set_std_prefs (const char *string,int personal)
348 {
349     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
350     int nsym=0, nhash=0, nzip=0, val, rc=0;
351     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
352     char dummy_string[20*4+1]; /* Enough for 20 items. */
353
354     if (!string || !ascii_strcasecmp (string, "default"))
355       {
356         if (opt.def_preference_list)
357           string=opt.def_preference_list;
358         else
359           {
360             int any_compress = 0;
361             dummy_string[0]='\0';
362
363             /* The rationale why we use the order AES256,192,128 is
364                for compatibility reasons with PGP.  If gpg would
365                define AES128 first, we would get the somewhat
366                confusing situation:
367
368                  gpg -r pgpkey -r gpgkey  ---gives--> AES256
369                  gpg -r gpgkey -r pgpkey  ---gives--> AES
370
371                Note that by using --personal-cipher-preferences it is
372                possible to prefer AES128.
373             */
374
375             /* Make sure we do not add more than 15 items here, as we
376                could overflow the size of dummy_string.  We currently
377                have at most 12. */
378             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES256) )
379               strcat(dummy_string,"S9 ");
380             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES192) )
381               strcat(dummy_string,"S8 ");
382             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES) )
383               strcat(dummy_string,"S7 ");
384             strcat(dummy_string,"S2 "); /* 3DES */
385
386             if (personal)
387               {
388                 /* The default internal hash algo order is:
389                  *  SHA-256, SHA-384, SHA-512, SHA-224, SHA-1.
390                  */
391                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
392                   strcat (dummy_string, "H8 ");
393
394                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
395                   strcat (dummy_string, "H9 ");
396
397                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
398                   strcat (dummy_string, "H10 ");
399               }
400             else
401               {
402                 /* The default advertised hash algo order is:
403                  *  SHA-512, SHA-384, SHA-256, SHA-224, SHA-1.
404                  */
405                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
406                   strcat (dummy_string, "H10 ");
407
408                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
409                   strcat (dummy_string, "H9 ");
410
411                 if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
412                   strcat (dummy_string, "H8 ");
413               }
414
415             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
416               strcat (dummy_string, "H11 ");
417
418             strcat (dummy_string, "H2 "); /* SHA-1 */
419
420             if(!check_compress_algo(COMPRESS_ALGO_ZLIB))
421               {
422                 strcat(dummy_string,"Z2 ");
423                 any_compress = 1;
424               }
425
426             if(!check_compress_algo(COMPRESS_ALGO_BZIP2))
427               {
428                 strcat(dummy_string,"Z3 ");
429                 any_compress = 1;
430               }
431
432             if(!check_compress_algo(COMPRESS_ALGO_ZIP))
433               {
434                 strcat(dummy_string,"Z1 ");
435                 any_compress = 1;
436               }
437
438             /* In case we have no compress algo at all, declare that
439                we prefer no compresssion.  */
440             if (!any_compress)
441               strcat(dummy_string,"Z0 ");
442
443             /* Remove the trailing space.  */
444             if (*dummy_string && dummy_string[strlen (dummy_string)-1] == ' ')
445               dummy_string[strlen (dummy_string)-1] = 0;
446
447             string=dummy_string;
448           }
449       }
450     else if (!ascii_strcasecmp (string, "none"))
451         string = "";
452
453     if(strlen(string))
454       {
455         char *prefstringbuf;
456         char *tok, *prefstring;
457
458         /* We need a writable string. */
459         prefstring = prefstringbuf = xstrdup (string);
460
461         while((tok=strsep(&prefstring," ,")))
462           {
463             if((val=string_to_cipher_algo (tok)))
464               {
465                 if(set_one_pref(val,1,tok,sym,&nsym))
466                   rc=-1;
467               }
468             else if((val=string_to_digest_algo (tok)))
469               {
470                 if(set_one_pref(val,2,tok,hash,&nhash))
471                   rc=-1;
472               }
473             else if((val=string_to_compress_algo(tok))>-1)
474               {
475                 if(set_one_pref(val,3,tok,zip,&nzip))
476                   rc=-1;
477               }
478             else if (ascii_strcasecmp(tok,"mdc")==0)
479               mdc=1;
480             else if (ascii_strcasecmp(tok,"no-mdc")==0)
481               mdc=0;
482             else if (ascii_strcasecmp(tok,"ks-modify")==0)
483               modify=1;
484             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
485               modify=0;
486             else
487               {
488                 log_info (_("invalid item '%s' in preference string\n"),tok);
489                 rc=-1;
490               }
491           }
492
493         xfree (prefstringbuf);
494       }
495
496     if(!rc)
497       {
498         if(personal)
499           {
500             if(personal==PREFTYPE_SYM)
501               {
502                 xfree(opt.personal_cipher_prefs);
503
504                 if(nsym==0)
505                   opt.personal_cipher_prefs=NULL;
506                 else
507                   {
508                     int i;
509
510                     opt.personal_cipher_prefs=
511                       xmalloc(sizeof(prefitem_t *)*(nsym+1));
512
513                     for (i=0; i<nsym; i++)
514                       {
515                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
516                         opt.personal_cipher_prefs[i].value = sym[i];
517                       }
518
519                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
520                     opt.personal_cipher_prefs[i].value = 0;
521                   }
522               }
523             else if(personal==PREFTYPE_HASH)
524               {
525                 xfree(opt.personal_digest_prefs);
526
527                 if(nhash==0)
528                   opt.personal_digest_prefs=NULL;
529                 else
530                   {
531                     int i;
532
533                     opt.personal_digest_prefs=
534                       xmalloc(sizeof(prefitem_t *)*(nhash+1));
535
536                     for (i=0; i<nhash; i++)
537                       {
538                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
539                         opt.personal_digest_prefs[i].value = hash[i];
540                       }
541
542                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
543                     opt.personal_digest_prefs[i].value = 0;
544                   }
545               }
546             else if(personal==PREFTYPE_ZIP)
547               {
548                 xfree(opt.personal_compress_prefs);
549
550                 if(nzip==0)
551                   opt.personal_compress_prefs=NULL;
552                 else
553                   {
554                     int i;
555
556                     opt.personal_compress_prefs=
557                       xmalloc(sizeof(prefitem_t *)*(nzip+1));
558
559                     for (i=0; i<nzip; i++)
560                       {
561                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
562                         opt.personal_compress_prefs[i].value = zip[i];
563                       }
564
565                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
566                     opt.personal_compress_prefs[i].value = 0;
567                   }
568               }
569           }
570         else
571           {
572             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
573             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
574             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
575             mdc_available = mdc;
576             ks_modify = modify;
577             prefs_initialized = 1;
578           }
579       }
580
581     return rc;
582 }
583
584 /* Return a fake user ID containing the preferences.  Caller must
585    free. */
586 PKT_user_id *
587 keygen_get_std_prefs(void)
588 {
589   int i,j=0;
590   PKT_user_id *uid=xmalloc_clear(sizeof(PKT_user_id));
591
592   if(!prefs_initialized)
593     keygen_set_std_prefs(NULL,0);
594
595   uid->ref=1;
596
597   uid->prefs=xmalloc((sizeof(prefitem_t *)*
598                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
599
600   for(i=0;i<nsym_prefs;i++,j++)
601     {
602       uid->prefs[j].type=PREFTYPE_SYM;
603       uid->prefs[j].value=sym_prefs[i];
604     }
605
606   for(i=0;i<nhash_prefs;i++,j++)
607     {
608       uid->prefs[j].type=PREFTYPE_HASH;
609       uid->prefs[j].value=hash_prefs[i];
610     }
611
612   for(i=0;i<nzip_prefs;i++,j++)
613     {
614       uid->prefs[j].type=PREFTYPE_ZIP;
615       uid->prefs[j].value=zip_prefs[i];
616     }
617
618   uid->prefs[j].type=PREFTYPE_NONE;
619   uid->prefs[j].value=0;
620
621   uid->flags.mdc=mdc_available;
622   uid->flags.ks_modify=ks_modify;
623
624   return uid;
625 }
626
627 static void
628 add_feature_mdc (PKT_signature *sig,int enabled)
629 {
630     const byte *s;
631     size_t n;
632     int i;
633     char *buf;
634
635     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
636     /* Already set or cleared */
637     if (s && n &&
638         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
639       return;
640
641     if (!s || !n) { /* create a new one */
642         n = 1;
643         buf = xmalloc_clear (n);
644     }
645     else {
646         buf = xmalloc (n);
647         memcpy (buf, s, n);
648     }
649
650     if(enabled)
651       buf[0] |= 0x01; /* MDC feature */
652     else
653       buf[0] &= ~0x01;
654
655     /* Are there any bits set? */
656     for(i=0;i<n;i++)
657       if(buf[i]!=0)
658         break;
659
660     if(i==n)
661       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
662     else
663       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
664
665     xfree (buf);
666 }
667
668 static void
669 add_keyserver_modify (PKT_signature *sig,int enabled)
670 {
671   const byte *s;
672   size_t n;
673   int i;
674   char *buf;
675
676   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
677   enabled=!enabled;
678
679   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
680   /* Already set or cleared */
681   if (s && n &&
682       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
683     return;
684
685   if (!s || !n) { /* create a new one */
686     n = 1;
687     buf = xmalloc_clear (n);
688   }
689   else {
690     buf = xmalloc (n);
691     memcpy (buf, s, n);
692   }
693
694   if(enabled)
695     buf[0] |= 0x80; /* no-modify flag */
696   else
697     buf[0] &= ~0x80;
698
699   /* Are there any bits set? */
700   for(i=0;i<n;i++)
701     if(buf[i]!=0)
702       break;
703
704   if(i==n)
705     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
706   else
707     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
708
709   xfree (buf);
710 }
711
712
713 int
714 keygen_upd_std_prefs (PKT_signature *sig, void *opaque)
715 {
716   (void)opaque;
717
718   if (!prefs_initialized)
719     keygen_set_std_prefs (NULL, 0);
720
721   if (nsym_prefs)
722     build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
723   else
724     {
725       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
726       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
727     }
728
729   if (nhash_prefs)
730     build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
731   else
732     {
733       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
734       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
735     }
736
737   if (nzip_prefs)
738     build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
739   else
740     {
741       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
742       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
743     }
744
745   /* Make sure that the MDC feature flag is set if needed.  */
746   add_feature_mdc (sig,mdc_available);
747   add_keyserver_modify (sig,ks_modify);
748   keygen_add_keyserver_url(sig,NULL);
749
750   return 0;
751 }
752
753
754 /****************
755  * Add preference to the self signature packet.
756  * This is only called for packets with version > 3.
757  */
758 int
759 keygen_add_std_prefs (PKT_signature *sig, void *opaque)
760 {
761   PKT_public_key *pk = opaque;
762
763   do_add_key_flags (sig, pk->pubkey_usage);
764   keygen_add_key_expire (sig, opaque );
765   keygen_upd_std_prefs (sig, opaque);
766   keygen_add_keyserver_url (sig,NULL);
767
768   return 0;
769 }
770
771 int
772 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
773 {
774   const char *url=opaque;
775
776   if(!url)
777     url=opt.def_keyserver_url;
778
779   if(url)
780     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
781   else
782     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
783
784   return 0;
785 }
786
787 int
788 keygen_add_notations(PKT_signature *sig,void *opaque)
789 {
790   struct notation *notation;
791
792   /* We always start clean */
793   delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
794   delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
795   sig->flags.notation=0;
796
797   for(notation=opaque;notation;notation=notation->next)
798     if(!notation->flags.ignore)
799       {
800         unsigned char *buf;
801         unsigned int n1,n2;
802
803         n1=strlen(notation->name);
804         if(notation->altvalue)
805           n2=strlen(notation->altvalue);
806         else if(notation->bdat)
807           n2=notation->blen;
808         else
809           n2=strlen(notation->value);
810
811         buf = xmalloc( 8 + n1 + n2 );
812
813         /* human readable or not */
814         buf[0] = notation->bdat?0:0x80;
815         buf[1] = buf[2] = buf[3] = 0;
816         buf[4] = n1 >> 8;
817         buf[5] = n1;
818         buf[6] = n2 >> 8;
819         buf[7] = n2;
820         memcpy(buf+8, notation->name, n1 );
821         if(notation->altvalue)
822           memcpy(buf+8+n1, notation->altvalue, n2 );
823         else if(notation->bdat)
824           memcpy(buf+8+n1, notation->bdat, n2 );
825         else
826           memcpy(buf+8+n1, notation->value, n2 );
827         build_sig_subpkt( sig, SIGSUBPKT_NOTATION |
828                           (notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
829                           buf, 8+n1+n2 );
830         xfree(buf);
831       }
832
833   return 0;
834 }
835
836 int
837 keygen_add_revkey (PKT_signature *sig, void *opaque)
838 {
839   struct revocation_key *revkey = opaque;
840   byte buf[2+MAX_FINGERPRINT_LEN];
841
842   buf[0] = revkey->class;
843   buf[1] = revkey->algid;
844   memcpy (&buf[2], revkey->fpr, MAX_FINGERPRINT_LEN);
845
846   build_sig_subpkt (sig, SIGSUBPKT_REV_KEY, buf, 2+MAX_FINGERPRINT_LEN);
847
848   /* All sigs with revocation keys set are nonrevocable.  */
849   sig->flags.revocable = 0;
850   buf[0] = 0;
851   build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
852
853   parse_revkeys (sig);
854
855   return 0;
856 }
857
858
859
860 /* Create a back-signature.  If TIMESTAMP is not NULL, use it for the
861    signature creation time.  */
862 gpg_error_t
863 make_backsig (ctrl_t ctrl, PKT_signature *sig, PKT_public_key *pk,
864               PKT_public_key *sub_pk, PKT_public_key *sub_psk,
865               u32 timestamp, const char *cache_nonce)
866 {
867   gpg_error_t err;
868   PKT_signature *backsig;
869
870   cache_public_key (sub_pk);
871
872   err = make_keysig_packet (ctrl, &backsig, pk, NULL, sub_pk, sub_psk, 0x19,
873                             0, timestamp, 0, NULL, NULL, cache_nonce);
874   if (err)
875     log_error ("make_keysig_packet failed for backsig: %s\n",
876                gpg_strerror (err));
877   else
878     {
879       /* Get it into a binary packed form. */
880       IOBUF backsig_out = iobuf_temp();
881       PACKET backsig_pkt;
882
883       init_packet (&backsig_pkt);
884       backsig_pkt.pkttype = PKT_SIGNATURE;
885       backsig_pkt.pkt.signature = backsig;
886       err = build_packet (backsig_out, &backsig_pkt);
887       free_packet (&backsig_pkt, NULL);
888       if (err)
889         log_error ("build_packet failed for backsig: %s\n", gpg_strerror (err));
890       else
891         {
892           size_t pktlen = 0;
893           byte *buf = iobuf_get_temp_buffer (backsig_out);
894
895           /* Remove the packet header. */
896           if(buf[0]&0x40)
897             {
898               if (buf[1] < 192)
899                 {
900                   pktlen = buf[1];
901                   buf += 2;
902                 }
903               else if(buf[1] < 224)
904                 {
905                   pktlen = (buf[1]-192)*256;
906                   pktlen += buf[2]+192;
907                   buf += 3;
908                 }
909               else if (buf[1] == 255)
910                 {
911                   pktlen = buf32_to_size_t (buf+2);
912                   buf += 6;
913                 }
914               else
915                 BUG ();
916             }
917           else
918             {
919               int mark = 1;
920
921               switch (buf[0]&3)
922                 {
923                 case 3:
924                   BUG ();
925                   break;
926
927                 case 2:
928                   pktlen  = (size_t)buf[mark++] << 24;
929                   pktlen |= buf[mark++] << 16;
930                   /* fall through */
931                 case 1:
932                   pktlen |= buf[mark++] << 8;
933                   /* fall through */
934                 case 0:
935                   pktlen |= buf[mark++];
936                 }
937
938               buf += mark;
939             }
940
941           /* Now make the binary blob into a subpacket.  */
942           build_sig_subpkt (sig, SIGSUBPKT_SIGNATURE, buf, pktlen);
943
944           iobuf_close (backsig_out);
945         }
946     }
947
948   return err;
949 }
950
951
952 /* Write a direct key signature to the first key in ROOT using the key
953    PSK.  REVKEY is describes the direct key signature and TIMESTAMP is
954    the timestamp to set on the signature.  */
955 static gpg_error_t
956 write_direct_sig (ctrl_t ctrl, kbnode_t root, PKT_public_key *psk,
957                   struct revocation_key *revkey, u32 timestamp,
958                   const char *cache_nonce)
959 {
960   gpg_error_t err;
961   PACKET *pkt;
962   PKT_signature *sig;
963   KBNODE node;
964   PKT_public_key *pk;
965
966   if (opt.verbose)
967     log_info (_("writing direct signature\n"));
968
969   /* Get the pk packet from the pub_tree. */
970   node = find_kbnode (root, PKT_PUBLIC_KEY);
971   if (!node)
972     BUG ();
973   pk = node->pkt->pkt.public_key;
974
975   /* We have to cache the key, so that the verification of the
976      signature creation is able to retrieve the public key.  */
977   cache_public_key (pk);
978
979   /* Make the signature.  */
980   err = make_keysig_packet (ctrl, &sig, pk, NULL,NULL, psk, 0x1F,
981                             0, timestamp, 0,
982                             keygen_add_revkey, revkey, cache_nonce);
983   if (err)
984     {
985       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err) );
986       return err;
987     }
988
989   pkt = xmalloc_clear (sizeof *pkt);
990   pkt->pkttype = PKT_SIGNATURE;
991   pkt->pkt.signature = sig;
992   add_kbnode (root, new_kbnode (pkt));
993   return err;
994 }
995
996
997
998 /* Write a self-signature to the first user id in ROOT using the key
999    PSK.  USE and TIMESTAMP give the extra data we need for the
1000    signature.  */
1001 static gpg_error_t
1002 write_selfsigs (ctrl_t ctrl, kbnode_t root, PKT_public_key *psk,
1003                 unsigned int use, u32 timestamp, const char *cache_nonce)
1004 {
1005   gpg_error_t err;
1006   PACKET *pkt;
1007   PKT_signature *sig;
1008   PKT_user_id *uid;
1009   KBNODE node;
1010   PKT_public_key *pk;
1011
1012   if (opt.verbose)
1013     log_info (_("writing self signature\n"));
1014
1015   /* Get the uid packet from the list. */
1016   node = find_kbnode (root, PKT_USER_ID);
1017   if (!node)
1018     BUG(); /* No user id packet in tree.  */
1019   uid = node->pkt->pkt.user_id;
1020
1021   /* Get the pk packet from the pub_tree. */
1022   node = find_kbnode (root, PKT_PUBLIC_KEY);
1023   if (!node)
1024     BUG();
1025   pk = node->pkt->pkt.public_key;
1026
1027   /* The usage has not yet been set - do it now. */
1028   pk->pubkey_usage = use;
1029
1030   /* We have to cache the key, so that the verification of the
1031      signature creation is able to retrieve the public key.  */
1032   cache_public_key (pk);
1033
1034   /* Make the signature.  */
1035   err = make_keysig_packet (ctrl, &sig, pk, uid, NULL, psk, 0x13,
1036                             0, timestamp, 0,
1037                             keygen_add_std_prefs, pk, cache_nonce);
1038   if (err)
1039     {
1040       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err));
1041       return err;
1042     }
1043
1044   pkt = xmalloc_clear (sizeof *pkt);
1045   pkt->pkttype = PKT_SIGNATURE;
1046   pkt->pkt.signature = sig;
1047   add_kbnode (root, new_kbnode (pkt));
1048
1049   return err;
1050 }
1051
1052
1053 /* Write the key binding signature.  If TIMESTAMP is not NULL use the
1054    signature creation time.  PRI_PSK is the key use for signing.
1055    SUB_PSK is a key used to create a back-signature; that one is only
1056    used if USE has the PUBKEY_USAGE_SIG capability.  */
1057 static int
1058 write_keybinding (ctrl_t ctrl, kbnode_t root,
1059                   PKT_public_key *pri_psk, PKT_public_key *sub_psk,
1060                   unsigned int use, u32 timestamp, const char *cache_nonce)
1061 {
1062   gpg_error_t err;
1063   PACKET *pkt;
1064   PKT_signature *sig;
1065   KBNODE node;
1066   PKT_public_key *pri_pk, *sub_pk;
1067   struct opaque_data_usage_and_pk oduap;
1068
1069   if (opt.verbose)
1070     log_info(_("writing key binding signature\n"));
1071
1072   /* Get the primary pk packet from the tree.  */
1073   node = find_kbnode (root, PKT_PUBLIC_KEY);
1074   if (!node)
1075     BUG();
1076   pri_pk = node->pkt->pkt.public_key;
1077
1078   /* We have to cache the key, so that the verification of the
1079    * signature creation is able to retrieve the public key.  */
1080   cache_public_key (pri_pk);
1081
1082   /* Find the last subkey. */
1083   sub_pk = NULL;
1084   for (node = root; node; node = node->next )
1085     {
1086       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1087         sub_pk = node->pkt->pkt.public_key;
1088     }
1089   if (!sub_pk)
1090     BUG();
1091
1092   /* Make the signature.  */
1093   oduap.usage = use;
1094   oduap.pk = sub_pk;
1095   err = make_keysig_packet (ctrl, &sig, pri_pk, NULL, sub_pk, pri_psk, 0x18,
1096                             0, timestamp, 0,
1097                             keygen_add_key_flags_and_expire, &oduap,
1098                             cache_nonce);
1099   if (err)
1100     {
1101       log_error ("make_keysig_packeto failed: %s\n", gpg_strerror (err));
1102       return err;
1103     }
1104
1105   /* Make a backsig.  */
1106   if (use & PUBKEY_USAGE_SIG)
1107     {
1108       err = make_backsig (ctrl,
1109                           sig, pri_pk, sub_pk, sub_psk, timestamp, cache_nonce);
1110       if (err)
1111         return err;
1112     }
1113
1114   pkt = xmalloc_clear ( sizeof *pkt );
1115   pkt->pkttype = PKT_SIGNATURE;
1116   pkt->pkt.signature = sig;
1117   add_kbnode (root, new_kbnode (pkt) );
1118   return err;
1119 }
1120
1121
1122 static gpg_error_t
1123 ecckey_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp, int algo)
1124 {
1125   gpg_error_t err;
1126   gcry_sexp_t list, l2;
1127   char *curve = NULL;
1128   int i;
1129   const char *oidstr;
1130   unsigned int nbits;
1131
1132   array[0] = NULL;
1133   array[1] = NULL;
1134   array[2] = NULL;
1135
1136   list = gcry_sexp_find_token (sexp, "public-key", 0);
1137   if (!list)
1138     return gpg_error (GPG_ERR_INV_OBJ);
1139   l2 = gcry_sexp_cadr (list);
1140   gcry_sexp_release (list);
1141   list = l2;
1142   if (!list)
1143     return gpg_error (GPG_ERR_NO_OBJ);
1144
1145   l2 = gcry_sexp_find_token (list, "curve", 0);
1146   if (!l2)
1147     {
1148       err = gpg_error (GPG_ERR_NO_OBJ);
1149       goto leave;
1150     }
1151   curve = gcry_sexp_nth_string (l2, 1);
1152   if (!curve)
1153     {
1154       err = gpg_error (GPG_ERR_NO_OBJ);
1155       goto leave;
1156     }
1157   gcry_sexp_release (l2);
1158   oidstr = openpgp_curve_to_oid (curve, &nbits);
1159   if (!oidstr)
1160     {
1161       /* That can't happen because we used one of the curves
1162          gpg_curve_to_oid knows about.  */
1163       err = gpg_error (GPG_ERR_INV_OBJ);
1164       goto leave;
1165     }
1166   err = openpgp_oid_from_str (oidstr, &array[0]);
1167   if (err)
1168     goto leave;
1169
1170   l2 = gcry_sexp_find_token (list, "q", 0);
1171   if (!l2)
1172     {
1173       err = gpg_error (GPG_ERR_NO_OBJ);
1174       goto leave;
1175     }
1176   array[1] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1177   gcry_sexp_release (l2);
1178   if (!array[1])
1179     {
1180       err = gpg_error (GPG_ERR_INV_OBJ);
1181       goto leave;
1182     }
1183   gcry_sexp_release (list);
1184
1185   if (algo == PUBKEY_ALGO_ECDH)
1186     {
1187       array[2] = pk_ecdh_default_params (nbits);
1188       if (!array[2])
1189         {
1190           err = gpg_error_from_syserror ();
1191           goto leave;
1192         }
1193     }
1194
1195  leave:
1196   xfree (curve);
1197   if (err)
1198     {
1199       for (i=0; i < 3; i++)
1200         {
1201           gcry_mpi_release (array[i]);
1202           array[i] = NULL;
1203         }
1204     }
1205   return err;
1206 }
1207
1208
1209 /* Extract key parameters from SEXP and store them in ARRAY.  ELEMS is
1210    a string where each character denotes a parameter name.  TOPNAME is
1211    the name of the top element above the elements.  */
1212 static int
1213 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
1214                const char *topname, const char *elems)
1215 {
1216   gcry_sexp_t list, l2;
1217   const char *s;
1218   int i, idx;
1219   int rc = 0;
1220
1221   list = gcry_sexp_find_token (sexp, topname, 0);
1222   if (!list)
1223     return gpg_error (GPG_ERR_INV_OBJ);
1224   l2 = gcry_sexp_cadr (list);
1225   gcry_sexp_release (list);
1226   list = l2;
1227   if (!list)
1228     return gpg_error (GPG_ERR_NO_OBJ);
1229
1230   for (idx=0,s=elems; *s; s++, idx++)
1231     {
1232       l2 = gcry_sexp_find_token (list, s, 1);
1233       if (!l2)
1234         {
1235           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
1236           goto leave;
1237         }
1238       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1239       gcry_sexp_release (l2);
1240       if (!array[idx])
1241         {
1242           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
1243           goto leave;
1244         }
1245     }
1246   gcry_sexp_release (list);
1247
1248  leave:
1249   if (rc)
1250     {
1251       for (i=0; i<idx; i++)
1252         {
1253           gcry_mpi_release (array[i]);
1254           array[i] = NULL;
1255         }
1256       gcry_sexp_release (list);
1257     }
1258   return rc;
1259 }
1260
1261
1262 /* Create a keyblock using the given KEYGRIP.  ALGO is the OpenPGP
1263    algorithm of that keygrip.  */
1264 static int
1265 do_create_from_keygrip (ctrl_t ctrl, int algo, const char *hexkeygrip,
1266                         kbnode_t pub_root, u32 timestamp, u32 expireval,
1267                         int is_subkey)
1268 {
1269   int err;
1270   PACKET *pkt;
1271   PKT_public_key *pk;
1272   gcry_sexp_t s_key;
1273   const char *algoelem;
1274
1275   if (hexkeygrip[0] == '&')
1276     hexkeygrip++;
1277
1278   switch (algo)
1279     {
1280     case PUBKEY_ALGO_RSA:       algoelem = "ne"; break;
1281     case PUBKEY_ALGO_DSA:       algoelem = "pqgy"; break;
1282     case PUBKEY_ALGO_ELGAMAL_E: algoelem = "pgy"; break;
1283     case PUBKEY_ALGO_ECDH:
1284     case PUBKEY_ALGO_ECDSA:     algoelem = ""; break;
1285     case PUBKEY_ALGO_EDDSA:     algoelem = ""; break;
1286     default: return gpg_error (GPG_ERR_INTERNAL);
1287     }
1288
1289
1290   /* Ask the agent for the public key matching HEXKEYGRIP.  */
1291   {
1292     unsigned char *public;
1293
1294     err = agent_readkey (ctrl, 0, hexkeygrip, &public);
1295     if (err)
1296       return err;
1297     err = gcry_sexp_sscan (&s_key, NULL,
1298                            public, gcry_sexp_canon_len (public, 0, NULL, NULL));
1299     xfree (public);
1300     if (err)
1301       return err;
1302   }
1303
1304   /* Build a public key packet.  */
1305   pk = xtrycalloc (1, sizeof *pk);
1306   if (!pk)
1307     {
1308       err = gpg_error_from_syserror ();
1309       gcry_sexp_release (s_key);
1310       return err;
1311     }
1312
1313   pk->timestamp = timestamp;
1314   pk->version = 4;
1315   if (expireval)
1316     pk->expiredate = pk->timestamp + expireval;
1317   pk->pubkey_algo = algo;
1318
1319   if (algo == PUBKEY_ALGO_ECDSA
1320       || algo == PUBKEY_ALGO_EDDSA
1321       || algo == PUBKEY_ALGO_ECDH )
1322     err = ecckey_from_sexp (pk->pkey, s_key, algo);
1323   else
1324     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1325   if (err)
1326     {
1327       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1328       gcry_sexp_release (s_key);
1329       free_public_key (pk);
1330       return err;
1331     }
1332   gcry_sexp_release (s_key);
1333
1334   pkt = xtrycalloc (1, sizeof *pkt);
1335   if (!pkt)
1336     {
1337       err = gpg_error_from_syserror ();
1338       free_public_key (pk);
1339       return err;
1340     }
1341
1342   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1343   pkt->pkt.public_key = pk;
1344   add_kbnode (pub_root, new_kbnode (pkt));
1345
1346   return 0;
1347 }
1348
1349
1350 /* Common code for the key generation function gen_xxx.  */
1351 static int
1352 common_gen (const char *keyparms, int algo, const char *algoelem,
1353             kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
1354             int keygen_flags, const char *passphrase,
1355             char **cache_nonce_addr, char **passwd_nonce_addr)
1356 {
1357   int err;
1358   PACKET *pkt;
1359   PKT_public_key *pk;
1360   gcry_sexp_t s_key;
1361
1362   err = agent_genkey (NULL, cache_nonce_addr, passwd_nonce_addr, keyparms,
1363                       !!(keygen_flags & KEYGEN_FLAG_NO_PROTECTION),
1364                       passphrase,
1365                       &s_key);
1366   if (err)
1367     {
1368       log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
1369       return err;
1370     }
1371
1372   pk = xtrycalloc (1, sizeof *pk);
1373   if (!pk)
1374     {
1375       err = gpg_error_from_syserror ();
1376       gcry_sexp_release (s_key);
1377       return err;
1378     }
1379
1380   pk->timestamp = timestamp;
1381   pk->version = 4;
1382   if (expireval)
1383     pk->expiredate = pk->timestamp + expireval;
1384   pk->pubkey_algo = algo;
1385
1386   if (algo == PUBKEY_ALGO_ECDSA
1387       || algo == PUBKEY_ALGO_EDDSA
1388       || algo == PUBKEY_ALGO_ECDH )
1389     err = ecckey_from_sexp (pk->pkey, s_key, algo);
1390   else
1391     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1392   if (err)
1393     {
1394       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1395       gcry_sexp_release (s_key);
1396       free_public_key (pk);
1397       return err;
1398     }
1399   gcry_sexp_release (s_key);
1400
1401   pkt = xtrycalloc (1, sizeof *pkt);
1402   if (!pkt)
1403     {
1404       err = gpg_error_from_syserror ();
1405       free_public_key (pk);
1406       return err;
1407     }
1408
1409   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1410   pkt->pkt.public_key = pk;
1411   add_kbnode (pub_root, new_kbnode (pkt));
1412
1413   return 0;
1414 }
1415
1416
1417 /*
1418  * Generate an Elgamal key.
1419  */
1420 static int
1421 gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
1422          u32 timestamp, u32 expireval, int is_subkey,
1423          int keygen_flags, const char *passphrase,
1424          char **cache_nonce_addr, char **passwd_nonce_addr)
1425 {
1426   int err;
1427   char *keyparms;
1428   char nbitsstr[35];
1429
1430   log_assert (is_ELGAMAL (algo));
1431
1432   if (nbits < 1024)
1433     {
1434       nbits = 2048;
1435       log_info (_("keysize invalid; using %u bits\n"), nbits );
1436     }
1437   else if (nbits > 4096)
1438     {
1439       nbits = 4096;
1440       log_info (_("keysize invalid; using %u bits\n"), nbits );
1441     }
1442
1443   if ((nbits % 32))
1444     {
1445       nbits = ((nbits + 31) / 32) * 32;
1446       log_info (_("keysize rounded up to %u bits\n"), nbits );
1447     }
1448
1449   /* Note that we use transient-key only if no-protection has also
1450      been enabled.  */
1451   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1452   keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)%s))",
1453                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1454                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
1455                            strlen (nbitsstr), nbitsstr,
1456                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1457                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1458                            "(transient-key)" : "" );
1459   if (!keyparms)
1460     err = gpg_error_from_syserror ();
1461   else
1462     {
1463       err = common_gen (keyparms, algo, "pgy",
1464                         pub_root, timestamp, expireval, is_subkey,
1465                         keygen_flags, passphrase,
1466                         cache_nonce_addr, passwd_nonce_addr);
1467       xfree (keyparms);
1468     }
1469
1470   return err;
1471 }
1472
1473
1474 /*
1475  * Generate an DSA key
1476  */
1477 static gpg_error_t
1478 gen_dsa (unsigned int nbits, KBNODE pub_root,
1479          u32 timestamp, u32 expireval, int is_subkey,
1480          int keygen_flags, const char *passphrase,
1481          char **cache_nonce_addr, char **passwd_nonce_addr)
1482 {
1483   int err;
1484   unsigned int qbits;
1485   char *keyparms;
1486   char nbitsstr[35];
1487   char qbitsstr[35];
1488
1489   if (nbits < 768)
1490     {
1491       nbits = 2048;
1492       log_info(_("keysize invalid; using %u bits\n"), nbits );
1493     }
1494   else if ( nbits > 3072 )
1495     {
1496       nbits = 3072;
1497       log_info(_("keysize invalid; using %u bits\n"), nbits );
1498     }
1499
1500   if( (nbits % 64) )
1501     {
1502       nbits = ((nbits + 63) / 64) * 64;
1503       log_info(_("keysize rounded up to %u bits\n"), nbits );
1504     }
1505
1506   /* To comply with FIPS rules we round up to the next value unless in
1507      expert mode.  */
1508   if (!opt.expert && nbits > 1024 && (nbits % 1024))
1509     {
1510       nbits = ((nbits + 1023) / 1024) * 1024;
1511       log_info(_("keysize rounded up to %u bits\n"), nbits );
1512     }
1513
1514   /*
1515     Figure out a q size based on the key size.  FIPS 180-3 says:
1516
1517     L = 1024, N = 160
1518     L = 2048, N = 224
1519     L = 2048, N = 256
1520     L = 3072, N = 256
1521
1522     2048/256 is an odd pair since there is also a 2048/224 and
1523     3072/256.  Matching sizes is not a very exact science.
1524
1525     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
1526     but less than 2048, and 160 for 1024 (DSA1).
1527   */
1528
1529   if (nbits > 2047)
1530     qbits = 256;
1531   else if ( nbits > 1024)
1532     qbits = 224;
1533   else
1534     qbits = 160;
1535
1536   if (qbits != 160 )
1537     log_info (_("WARNING: some OpenPGP programs can't"
1538                 " handle a DSA key with this digest size\n"));
1539
1540   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1541   snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
1542   keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)%s))",
1543                            strlen (nbitsstr), nbitsstr,
1544                            strlen (qbitsstr), qbitsstr,
1545                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1546                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1547                            "(transient-key)" : "" );
1548   if (!keyparms)
1549     err = gpg_error_from_syserror ();
1550   else
1551     {
1552       err = common_gen (keyparms, PUBKEY_ALGO_DSA, "pqgy",
1553                         pub_root, timestamp, expireval, is_subkey,
1554                         keygen_flags, passphrase,
1555                         cache_nonce_addr, passwd_nonce_addr);
1556       xfree (keyparms);
1557     }
1558
1559   return err;
1560 }
1561
1562
1563
1564 /*
1565  * Generate an ECC key
1566  */
1567 static gpg_error_t
1568 gen_ecc (int algo, const char *curve, kbnode_t pub_root,
1569          u32 timestamp, u32 expireval, int is_subkey,
1570          int keygen_flags, const char *passphrase,
1571          char **cache_nonce_addr, char **passwd_nonce_addr)
1572 {
1573   gpg_error_t err;
1574   char *keyparms;
1575
1576   log_assert (algo == PUBKEY_ALGO_ECDSA
1577               || algo == PUBKEY_ALGO_EDDSA
1578               || algo == PUBKEY_ALGO_ECDH);
1579
1580   if (!curve || !*curve)
1581     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
1582
1583   /* Note that we use the "comp" flag with EdDSA to request the use of
1584      a 0x40 compression prefix octet.  */
1585   if (algo == PUBKEY_ALGO_EDDSA)
1586     keyparms = xtryasprintf
1587       ("(genkey(ecc(curve %zu:%s)(flags eddsa comp%s)))",
1588        strlen (curve), curve,
1589        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1590          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1591         " transient-key" : ""));
1592   else if (algo == PUBKEY_ALGO_ECDH && !strcmp (curve, "Curve25519"))
1593     keyparms = xtryasprintf
1594       ("(genkey(ecc(curve %zu:%s)(flags djb-tweak comp%s)))",
1595        strlen (curve), curve,
1596        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1597          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1598         " transient-key" : ""));
1599   else
1600     keyparms = xtryasprintf
1601       ("(genkey(ecc(curve %zu:%s)(flags nocomp%s)))",
1602        strlen (curve), curve,
1603        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1604          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1605         " transient-key" : ""));
1606
1607   if (!keyparms)
1608     err = gpg_error_from_syserror ();
1609   else
1610     {
1611       err = common_gen (keyparms, algo, "",
1612                         pub_root, timestamp, expireval, is_subkey,
1613                         keygen_flags, passphrase,
1614                         cache_nonce_addr, passwd_nonce_addr);
1615       xfree (keyparms);
1616     }
1617
1618   return err;
1619 }
1620
1621
1622 /*
1623  * Generate an RSA key.
1624  */
1625 static int
1626 gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
1627          u32 timestamp, u32 expireval, int is_subkey,
1628          int keygen_flags, const char *passphrase,
1629          char **cache_nonce_addr, char **passwd_nonce_addr)
1630 {
1631   int err;
1632   char *keyparms;
1633   char nbitsstr[35];
1634   const unsigned maxsize = (opt.flags.large_rsa ? 8192 : 4096);
1635
1636   log_assert (is_RSA(algo));
1637
1638   if (!nbits)
1639     nbits = get_keysize_range (algo, NULL, NULL);
1640
1641   if (nbits < 1024)
1642     {
1643       nbits = 3072;
1644       log_info (_("keysize invalid; using %u bits\n"), nbits );
1645     }
1646   else if (nbits > maxsize)
1647     {
1648       nbits = maxsize;
1649       log_info (_("keysize invalid; using %u bits\n"), nbits );
1650     }
1651
1652   if ((nbits % 32))
1653     {
1654       nbits = ((nbits + 31) / 32) * 32;
1655       log_info (_("keysize rounded up to %u bits\n"), nbits );
1656     }
1657
1658   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1659   keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)%s))",
1660                            strlen (nbitsstr), nbitsstr,
1661                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1662                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1663                            "(transient-key)" : "" );
1664   if (!keyparms)
1665     err = gpg_error_from_syserror ();
1666   else
1667     {
1668       err = common_gen (keyparms, algo, "ne",
1669                         pub_root, timestamp, expireval, is_subkey,
1670                         keygen_flags, passphrase,
1671                         cache_nonce_addr, passwd_nonce_addr);
1672       xfree (keyparms);
1673     }
1674
1675   return err;
1676 }
1677
1678
1679 /****************
1680  * check valid days:
1681  * return 0 on error or the multiplier
1682  */
1683 static int
1684 check_valid_days( const char *s )
1685 {
1686     if( !digitp(s) )
1687         return 0;
1688     for( s++; *s; s++)
1689         if( !digitp(s) )
1690             break;
1691     if( !*s )
1692         return 1;
1693     if( s[1] )
1694         return 0; /* e.g. "2323wc" */
1695     if( *s == 'd' || *s == 'D' )
1696         return 1;
1697     if( *s == 'w' || *s == 'W' )
1698         return 7;
1699     if( *s == 'm' || *s == 'M' )
1700         return 30;
1701     if( *s == 'y' || *s == 'Y' )
1702         return 365;
1703     return 0;
1704 }
1705
1706
1707 static void
1708 print_key_flags(int flags)
1709 {
1710   if(flags&PUBKEY_USAGE_SIG)
1711     tty_printf("%s ",_("Sign"));
1712
1713   if(flags&PUBKEY_USAGE_CERT)
1714     tty_printf("%s ",_("Certify"));
1715
1716   if(flags&PUBKEY_USAGE_ENC)
1717     tty_printf("%s ",_("Encrypt"));
1718
1719   if(flags&PUBKEY_USAGE_AUTH)
1720     tty_printf("%s ",_("Authenticate"));
1721 }
1722
1723
1724 /* Ask for the key flags and return them.  CURRENT gives the current
1725  * usage which should normally be given as 0. */
1726 unsigned int
1727 ask_key_flags (int algo, int subkey, unsigned int current)
1728 {
1729   /* TRANSLATORS: Please use only plain ASCII characters for the
1730      translation.  If this is not possible use single digits.  The
1731      string needs to 8 bytes long. Here is a description of the
1732      functions:
1733
1734        s = Toggle signing capability
1735        e = Toggle encryption capability
1736        a = Toggle authentication capability
1737        q = Finish
1738   */
1739   const char *togglers = _("SsEeAaQq");
1740   char *answer = NULL;
1741   const char *s;
1742   unsigned int possible = openpgp_pk_algo_usage(algo);
1743
1744   if ( strlen(togglers) != 8 )
1745     {
1746       tty_printf ("NOTE: Bad translation at %s:%d. "
1747                   "Please report.\n", __FILE__, __LINE__);
1748       togglers = "11223300";
1749     }
1750
1751   /* Only primary keys may certify. */
1752   if(subkey)
1753     possible&=~PUBKEY_USAGE_CERT;
1754
1755   /* Preload the current set with the possible set, minus
1756      authentication if CURRENT has been given as 0.  If CURRENT has
1757      been has non-zero we mask with all possible usages. */
1758   if (current)
1759     current &= possible;
1760   else
1761     current = (possible&~PUBKEY_USAGE_AUTH);
1762
1763   for(;;)
1764     {
1765       tty_printf("\n");
1766       tty_printf(_("Possible actions for a %s key: "),
1767                  (algo == PUBKEY_ALGO_ECDSA
1768                   || algo == PUBKEY_ALGO_EDDSA)
1769                  ? "ECDSA/EdDSA" : openpgp_pk_algo_name (algo));
1770       print_key_flags(possible);
1771       tty_printf("\n");
1772       tty_printf(_("Current allowed actions: "));
1773       print_key_flags(current);
1774       tty_printf("\n\n");
1775
1776       if(possible&PUBKEY_USAGE_SIG)
1777         tty_printf(_("   (%c) Toggle the sign capability\n"),
1778                    togglers[0]);
1779       if(possible&PUBKEY_USAGE_ENC)
1780         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1781                    togglers[2]);
1782       if(possible&PUBKEY_USAGE_AUTH)
1783         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1784                    togglers[4]);
1785
1786       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1787       tty_printf("\n");
1788
1789       xfree(answer);
1790       answer = cpr_get("keygen.flags",_("Your selection? "));
1791       cpr_kill_prompt();
1792
1793       if (*answer == '=')
1794         {
1795           /* Hack to allow direct entry of the capabilities.  */
1796           current = 0;
1797           for (s=answer+1; *s; s++)
1798             {
1799               if ((*s == 's' || *s == 'S') && (possible&PUBKEY_USAGE_SIG))
1800                 current |= PUBKEY_USAGE_SIG;
1801               else if ((*s == 'e' || *s == 'E') && (possible&PUBKEY_USAGE_ENC))
1802                 current |= PUBKEY_USAGE_ENC;
1803               else if ((*s == 'a' || *s == 'A') && (possible&PUBKEY_USAGE_AUTH))
1804                 current |= PUBKEY_USAGE_AUTH;
1805               else if (!subkey && *s == 'c')
1806                 {
1807                   /* Accept 'c' for the primary key because USAGE_CERT
1808                      will be set anyway.  This is for folks who
1809                      want to experiment with a cert-only primary key.  */
1810                   current |= PUBKEY_USAGE_CERT;
1811                 }
1812             }
1813           break;
1814         }
1815       else if (strlen(answer)>1)
1816         tty_printf(_("Invalid selection.\n"));
1817       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1818         break;
1819       else if((*answer==togglers[0] || *answer==togglers[1])
1820               && possible&PUBKEY_USAGE_SIG)
1821         {
1822           if(current&PUBKEY_USAGE_SIG)
1823             current&=~PUBKEY_USAGE_SIG;
1824           else
1825             current|=PUBKEY_USAGE_SIG;
1826         }
1827       else if((*answer==togglers[2] || *answer==togglers[3])
1828               && possible&PUBKEY_USAGE_ENC)
1829         {
1830           if(current&PUBKEY_USAGE_ENC)
1831             current&=~PUBKEY_USAGE_ENC;
1832           else
1833             current|=PUBKEY_USAGE_ENC;
1834         }
1835       else if((*answer==togglers[4] || *answer==togglers[5])
1836               && possible&PUBKEY_USAGE_AUTH)
1837         {
1838           if(current&PUBKEY_USAGE_AUTH)
1839             current&=~PUBKEY_USAGE_AUTH;
1840           else
1841             current|=PUBKEY_USAGE_AUTH;
1842         }
1843       else
1844         tty_printf(_("Invalid selection.\n"));
1845     }
1846
1847   xfree(answer);
1848
1849   return current;
1850 }
1851
1852
1853 /* Check whether we have a key for the key with HEXGRIP.  Returns 0 if
1854    there is no such key or the OpenPGP algo number for the key.  */
1855 static int
1856 check_keygrip (ctrl_t ctrl, const char *hexgrip)
1857 {
1858   gpg_error_t err;
1859   unsigned char *public;
1860   size_t publiclen;
1861   int algo;
1862
1863   if (hexgrip[0] == '&')
1864     hexgrip++;
1865
1866   err = agent_readkey (ctrl, 0, hexgrip, &public);
1867   if (err)
1868     return 0;
1869   publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);
1870
1871   algo = get_pk_algo_from_canon_sexp (public, publiclen);
1872   xfree (public);
1873
1874   return map_pk_gcry_to_openpgp (algo);
1875 }
1876
1877
1878
1879 /* Ask for an algorithm.  The function returns the algorithm id to
1880  * create. If ADDMODE is false the function won't show an option to
1881  * create the primary and subkey combined and won't set R_USAGE
1882  * either.  If a combined algorithm has been selected, the subkey
1883  * algorithm is stored at R_SUBKEY_ALGO.  If R_KEYGRIP is given, the
1884  * user has the choice to enter the keygrip of an existing key.  That
1885  * keygrip is then stored at this address.  The caller needs to free
1886  * it. */
1887 static int
1888 ask_algo (ctrl_t ctrl, int addmode, int *r_subkey_algo, unsigned int *r_usage,
1889           char **r_keygrip)
1890 {
1891   char *keygrip = NULL;
1892   char *answer = NULL;
1893   int algo;
1894   int dummy_algo;
1895
1896   if (!r_subkey_algo)
1897     r_subkey_algo = &dummy_algo;
1898
1899   tty_printf (_("Please select what kind of key you want:\n"));
1900
1901 #if GPG_USE_RSA
1902   if (!addmode)
1903     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1904 #endif
1905
1906   if (!addmode && opt.compliance != CO_DE_VS)
1907     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1908
1909   if (opt.compliance != CO_DE_VS)
1910     tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1911 #if GPG_USE_RSA
1912   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1913 #endif
1914
1915   if (addmode)
1916     {
1917       if (opt.compliance != CO_DE_VS)
1918         tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1919 #if GPG_USE_RSA
1920       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1921 #endif
1922     }
1923   if (opt.expert)
1924     {
1925       if (opt.compliance != CO_DE_VS)
1926         tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1927 #if GPG_USE_RSA
1928       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1929 #endif
1930     }
1931
1932 #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
1933   if (opt.expert && !addmode)
1934     tty_printf (_("   (%d) ECC and ECC\n"), 9 );
1935   if (opt.expert)
1936     tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
1937   if (opt.expert)
1938     tty_printf (_("  (%d) ECC (set your own capabilities)\n"), 11 );
1939   if (opt.expert && addmode)
1940     tty_printf (_("  (%d) ECC (encrypt only)\n"), 12 );
1941 #endif
1942
1943   if (opt.expert && r_keygrip)
1944     tty_printf (_("  (%d) Existing key\n"), 13 );
1945
1946   for (;;)
1947     {
1948       *r_usage = 0;
1949       *r_subkey_algo = 0;
1950       xfree (answer);
1951       answer = cpr_get ("keygen.algo", _("Your selection? "));
1952       cpr_kill_prompt ();
1953       algo = *answer? atoi (answer) : 1;
1954
1955       if (opt.compliance == CO_DE_VS
1956           && (algo == 2 || algo == 3 || algo == 5 || algo == 7))
1957         {
1958           tty_printf (_("Invalid selection.\n"));
1959         }
1960       else if ((algo == 1 || !strcmp (answer, "rsa+rsa")) && !addmode)
1961         {
1962           algo = PUBKEY_ALGO_RSA;
1963           *r_subkey_algo = PUBKEY_ALGO_RSA;
1964           break;
1965         }
1966       else if ((algo == 2 || !strcmp (answer, "dsa+elg")) && !addmode)
1967         {
1968           algo = PUBKEY_ALGO_DSA;
1969           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1970           break;
1971         }
1972       else if (algo == 3 || !strcmp (answer, "dsa"))
1973         {
1974           algo = PUBKEY_ALGO_DSA;
1975           *r_usage = PUBKEY_USAGE_SIG;
1976           break;
1977         }
1978       else if (algo == 4 || !strcmp (answer, "rsa/s"))
1979         {
1980           algo = PUBKEY_ALGO_RSA;
1981           *r_usage = PUBKEY_USAGE_SIG;
1982           break;
1983         }
1984       else if ((algo == 5 || !strcmp (answer, "elg")) && addmode)
1985         {
1986           algo = PUBKEY_ALGO_ELGAMAL_E;
1987           *r_usage = PUBKEY_USAGE_ENC;
1988           break;
1989         }
1990       else if ((algo == 6 || !strcmp (answer, "rsa/e")) && addmode)
1991         {
1992           algo = PUBKEY_ALGO_RSA;
1993           *r_usage = PUBKEY_USAGE_ENC;
1994           break;
1995         }
1996       else if ((algo == 7 || !strcmp (answer, "dsa/*")) && opt.expert)
1997         {
1998           algo = PUBKEY_ALGO_DSA;
1999           *r_usage = ask_key_flags (algo, addmode, 0);
2000           break;
2001         }
2002       else if ((algo == 8 || !strcmp (answer, "rsa/*")) && opt.expert)
2003         {
2004           algo = PUBKEY_ALGO_RSA;
2005           *r_usage = ask_key_flags (algo, addmode, 0);
2006           break;
2007         }
2008       else if ((algo == 9 || !strcmp (answer, "ecc+ecc"))
2009                && opt.expert && !addmode)
2010         {
2011           algo = PUBKEY_ALGO_ECDSA;
2012           *r_subkey_algo = PUBKEY_ALGO_ECDH;
2013           break;
2014         }
2015       else if ((algo == 10 || !strcmp (answer, "ecc/s")) && opt.expert)
2016         {
2017           algo = PUBKEY_ALGO_ECDSA;
2018           *r_usage = PUBKEY_USAGE_SIG;
2019           break;
2020         }
2021       else if ((algo == 11 || !strcmp (answer, "ecc/*")) && opt.expert)
2022         {
2023           algo = PUBKEY_ALGO_ECDSA;
2024           *r_usage = ask_key_flags (algo, addmode, 0);
2025           break;
2026         }
2027       else if ((algo == 12 || !strcmp (answer, "ecc/e"))
2028                && opt.expert && addmode)
2029         {
2030           algo = PUBKEY_ALGO_ECDH;
2031           *r_usage = PUBKEY_USAGE_ENC;
2032           break;
2033         }
2034       else if ((algo == 13 || !strcmp (answer, "keygrip"))
2035                && opt.expert && r_keygrip)
2036         {
2037           for (;;)
2038             {
2039               xfree (answer);
2040               answer = tty_get (_("Enter the keygrip: "));
2041               tty_kill_prompt ();
2042               trim_spaces (answer);
2043               if (!*answer)
2044                 {
2045                   xfree (answer);
2046                   answer = NULL;
2047                   continue;
2048                 }
2049
2050               if (strlen (answer) != 40 &&
2051                        !(answer[0] == '&' && strlen (answer+1) == 40))
2052                 tty_printf
2053                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
2054               else if (!(algo = check_keygrip (ctrl, answer)) )
2055                 tty_printf (_("No key with this keygrip\n"));
2056               else
2057                 break; /* Okay.  */
2058             }
2059           xfree (keygrip);
2060           keygrip = answer;
2061           answer = NULL;
2062           *r_usage = ask_key_flags (algo, addmode, 0);
2063           break;
2064         }
2065       else
2066         tty_printf (_("Invalid selection.\n"));
2067
2068     }
2069
2070   xfree(answer);
2071   if (r_keygrip)
2072     *r_keygrip = keygrip;
2073   return algo;
2074 }
2075
2076
2077 static unsigned int
2078 get_keysize_range (int algo, unsigned int *min, unsigned int *max)
2079 {
2080   unsigned int def;
2081   unsigned int dummy1, dummy2;
2082
2083   if (!min)
2084     min = &dummy1;
2085   if (!max)
2086     max = &dummy2;
2087
2088   switch(algo)
2089     {
2090     case PUBKEY_ALGO_DSA:
2091       *min = opt.expert? 768 : 1024;
2092       *max=3072;
2093       def=2048;
2094       break;
2095
2096     case PUBKEY_ALGO_ECDSA:
2097     case PUBKEY_ALGO_ECDH:
2098       *min=256;
2099       *max=521;
2100       def=256;
2101       break;
2102
2103     case PUBKEY_ALGO_EDDSA:
2104       *min=255;
2105       *max=441;
2106       def=255;
2107       break;
2108
2109     default:
2110       *min = opt.compliance == CO_DE_VS ? 2048: 1024;
2111       *max = 4096;
2112       def = 3072;
2113       break;
2114     }
2115
2116   return def;
2117 }
2118
2119
2120 /* Return a fixed up keysize depending on ALGO.  */
2121 static unsigned int
2122 fixup_keysize (unsigned int nbits, int algo, int silent)
2123 {
2124   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
2125     {
2126       nbits = ((nbits + 63) / 64) * 64;
2127       if (!silent)
2128         tty_printf (_("rounded up to %u bits\n"), nbits);
2129     }
2130   else if (algo == PUBKEY_ALGO_EDDSA)
2131     {
2132       if (nbits != 255 && nbits != 441)
2133         {
2134           if (nbits < 256)
2135             nbits = 255;
2136           else
2137             nbits = 441;
2138           if (!silent)
2139             tty_printf (_("rounded to %u bits\n"), nbits);
2140         }
2141     }
2142   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2143     {
2144       if (nbits != 256 && nbits != 384 && nbits != 521)
2145         {
2146           if (nbits < 256)
2147             nbits = 256;
2148           else if (nbits < 384)
2149             nbits = 384;
2150           else
2151             nbits = 521;
2152           if (!silent)
2153             tty_printf (_("rounded to %u bits\n"), nbits);
2154         }
2155     }
2156   else if ((nbits % 32))
2157     {
2158       nbits = ((nbits + 31) / 32) * 32;
2159       if (!silent)
2160         tty_printf (_("rounded up to %u bits\n"), nbits );
2161     }
2162
2163   return nbits;
2164 }
2165
2166
2167 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
2168    is not 0, the function asks for the size of the encryption
2169    subkey. */
2170 static unsigned
2171 ask_keysize (int algo, unsigned int primary_keysize)
2172 {
2173   unsigned int nbits;
2174   unsigned int min, def, max;
2175   int for_subkey = !!primary_keysize;
2176   int autocomp = 0;
2177
2178   def = get_keysize_range (algo, &min, &max);
2179
2180   if (primary_keysize && !opt.expert)
2181     {
2182       /* Deduce the subkey size from the primary key size.  */
2183       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
2184         nbits = 3072; /* For performance reasons we don't support more
2185                          than 3072 bit DSA.  However we won't see this
2186                          case anyway because DSA can't be used as an
2187                          encryption subkey ;-). */
2188       else
2189         nbits = primary_keysize;
2190       autocomp = 1;
2191       goto leave;
2192     }
2193
2194   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
2195              openpgp_pk_algo_name (algo), min, max);
2196
2197   for (;;)
2198     {
2199       char *prompt, *answer;
2200
2201       if (for_subkey)
2202         prompt = xasprintf (_("What keysize do you want "
2203                               "for the subkey? (%u) "), def);
2204       else
2205         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
2206       answer = cpr_get ("keygen.size", prompt);
2207       cpr_kill_prompt ();
2208       nbits = *answer? atoi (answer): def;
2209       xfree(prompt);
2210       xfree(answer);
2211
2212       if(nbits<min || nbits>max)
2213         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
2214                    openpgp_pk_algo_name (algo), min, max);
2215       else
2216         break;
2217     }
2218
2219   tty_printf (_("Requested keysize is %u bits\n"), nbits);
2220
2221  leave:
2222   nbits = fixup_keysize (nbits, algo, autocomp);
2223   return nbits;
2224 }
2225
2226
2227 /* Ask for the curve.  ALGO is the selected algorithm which this
2228    function may adjust.  Returns a malloced string with the name of
2229    the curve.  BOTH tells that gpg creates a primary and subkey. */
2230 static char *
2231 ask_curve (int *algo, int *subkey_algo)
2232 {
2233   /* NB: We always use a complete algo list so that we have stable
2234      numbers in the menu regardless on how Gpg was configured.  */
2235   struct {
2236     const char *name;
2237     const char* eddsa_curve; /* Corresponding EdDSA curve.  */
2238     const char *pretty_name;
2239     unsigned int supported : 1;   /* Supported by gpg.     */
2240     unsigned int de_vs : 1;       /* Allowed in CO_DE_VS.  */
2241     unsigned int expert_only : 1; /* Only with --expert    */
2242     unsigned int available : 1;   /* Available in Libycrypt (runtime checked) */
2243   } curves[] = {
2244 #if GPG_USE_ECDSA || GPG_USE_ECDH
2245 # define MY_USE_ECDSADH 1
2246 #else
2247 # define MY_USE_ECDSADH 0
2248 #endif
2249     { "Curve25519",      "Ed25519", "Curve 25519", !!GPG_USE_EDDSA, 0, 0, 0 },
2250     { "Curve448",        "Ed448",   "Curve 448",   0/*reserved*/  , 0, 1, 0 },
2251     { "NIST P-256",      NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2252     { "NIST P-384",      NULL, NULL,               MY_USE_ECDSADH,  0, 0, 0 },
2253     { "NIST P-521",      NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2254     { "brainpoolP256r1", NULL, "Brainpool P-256",  MY_USE_ECDSADH,  1, 1, 0 },
2255     { "brainpoolP384r1", NULL, "Brainpool P-384",  MY_USE_ECDSADH,  1, 1, 0 },
2256     { "brainpoolP512r1", NULL, "Brainpool P-512",  MY_USE_ECDSADH,  1, 1, 0 },
2257     { "secp256k1",       NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2258   };
2259 #undef MY_USE_ECDSADH
2260   int idx;
2261   char *answer;
2262   char *result = NULL;
2263   gcry_sexp_t keyparms;
2264
2265   tty_printf (_("Please select which elliptic curve you want:\n"));
2266
2267   keyparms = NULL;
2268   for (idx=0; idx < DIM(curves); idx++)
2269     {
2270       int rc;
2271
2272       curves[idx].available = 0;
2273       if (!curves[idx].supported)
2274         continue;
2275
2276       if (opt.compliance==CO_DE_VS)
2277         {
2278           if (!curves[idx].de_vs)
2279             continue; /* Not allowed.  */
2280         }
2281       else if (!opt.expert && curves[idx].expert_only)
2282         continue;
2283
2284       /* We need to switch from the ECDH name of the curve to the
2285          EDDSA name of the curve if we want a signing key.  */
2286       gcry_sexp_release (keyparms);
2287       rc = gcry_sexp_build (&keyparms, NULL,
2288                             "(public-key(ecc(curve %s)))",
2289                             curves[idx].eddsa_curve? curves[idx].eddsa_curve
2290                             /**/                   : curves[idx].name);
2291       if (rc)
2292         continue;
2293       if (!gcry_pk_get_curve (keyparms, 0, NULL))
2294         continue;
2295       if (subkey_algo && curves[idx].eddsa_curve)
2296         {
2297           /* Both Curve 25519 (or 448) keys are to be created.  Check that
2298              Libgcrypt also supports the real Curve25519 (or 448).  */
2299           gcry_sexp_release (keyparms);
2300           rc = gcry_sexp_build (&keyparms, NULL,
2301                                 "(public-key(ecc(curve %s)))",
2302                                  curves[idx].name);
2303           if (rc)
2304             continue;
2305           if (!gcry_pk_get_curve (keyparms, 0, NULL))
2306             continue;
2307         }
2308
2309       curves[idx].available = 1;
2310       tty_printf ("   (%d) %s\n", idx + 1,
2311                   curves[idx].pretty_name?
2312                   curves[idx].pretty_name:curves[idx].name);
2313     }
2314   gcry_sexp_release (keyparms);
2315
2316
2317   for (;;)
2318     {
2319       answer = cpr_get ("keygen.curve", _("Your selection? "));
2320       cpr_kill_prompt ();
2321       idx = *answer? atoi (answer) : 1;
2322       if (*answer && !idx)
2323         {
2324           /* See whether the user entered the name of the curve.  */
2325           for (idx=0; idx < DIM(curves); idx++)
2326             {
2327               if (!opt.expert && curves[idx].expert_only)
2328                 continue;
2329               if (!stricmp (curves[idx].name, answer)
2330                   || (curves[idx].pretty_name
2331                       && !stricmp (curves[idx].pretty_name, answer)))
2332                 break;
2333             }
2334           if (idx == DIM(curves))
2335             idx = -1;
2336         }
2337       else
2338         idx--;
2339       xfree(answer);
2340       answer = NULL;
2341       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
2342         tty_printf (_("Invalid selection.\n"));
2343       else
2344         {
2345           /* If the user selected a signing algorithm and Curve25519
2346              we need to set the algo to EdDSA and update the curve name. */
2347           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
2348               && curves[idx].eddsa_curve)
2349             {
2350               if (subkey_algo && *subkey_algo == PUBKEY_ALGO_ECDSA)
2351                 *subkey_algo = PUBKEY_ALGO_EDDSA;
2352               *algo = PUBKEY_ALGO_EDDSA;
2353               result = xstrdup (curves[idx].eddsa_curve);
2354             }
2355           else
2356             result = xstrdup (curves[idx].name);
2357           break;
2358         }
2359     }
2360
2361   if (!result)
2362     result = xstrdup (curves[0].name);
2363
2364   return result;
2365 }
2366
2367
2368 /****************
2369  * Parse an expire string and return its value in seconds.
2370  * Returns (u32)-1 on error.
2371  * This isn't perfect since scan_isodatestr returns unix time, and
2372  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
2373  * Because of this, we only permit setting expirations up to 2106, but
2374  * OpenPGP could theoretically allow up to 2242.  I think we'll all
2375  * just cope for the next few years until we get a 64-bit time_t or
2376  * similar.
2377  */
2378 u32
2379 parse_expire_string( const char *string )
2380 {
2381   int mult;
2382   u32 seconds;
2383   u32 abs_date = 0;
2384   u32 curtime = make_timestamp ();
2385   time_t tt;
2386
2387   if (!string || !*string || !strcmp (string, "none")
2388       || !strcmp (string, "never") || !strcmp (string, "-"))
2389     seconds = 0;
2390   else if (!strncmp (string, "seconds=", 8))
2391     seconds = atoi (string+8);
2392   else if ((abs_date = scan_isodatestr(string))
2393            && (abs_date+86400/2) > curtime)
2394     seconds = (abs_date+86400/2) - curtime;
2395   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
2396     seconds = (u32)tt - curtime;
2397   else if ((mult = check_valid_days (string)))
2398     seconds = atoi (string) * 86400L * mult;
2399   else
2400     seconds = (u32)(-1);
2401
2402   return seconds;
2403 }
2404
2405 /* Parse a Creation-Date string which is either "1986-04-26" or
2406    "19860426T042640".  Returns 0 on error. */
2407 static u32
2408 parse_creation_string (const char *string)
2409 {
2410   u32 seconds;
2411
2412   if (!*string)
2413     seconds = 0;
2414   else if ( !strncmp (string, "seconds=", 8) )
2415     seconds = atoi (string+8);
2416   else if ( !(seconds = scan_isodatestr (string)))
2417     {
2418       time_t tmp = isotime2epoch (string);
2419       seconds = (tmp == (time_t)(-1))? 0 : tmp;
2420     }
2421   return seconds;
2422 }
2423
2424
2425 /* object == 0 for a key, and 1 for a sig */
2426 u32
2427 ask_expire_interval(int object,const char *def_expire)
2428 {
2429     u32 interval;
2430     char *answer;
2431
2432     switch(object)
2433       {
2434       case 0:
2435         if(def_expire)
2436           BUG();
2437         tty_printf(_("Please specify how long the key should be valid.\n"
2438                      "         0 = key does not expire\n"
2439                      "      <n>  = key expires in n days\n"
2440                      "      <n>w = key expires in n weeks\n"
2441                      "      <n>m = key expires in n months\n"
2442                      "      <n>y = key expires in n years\n"));
2443         break;
2444
2445       case 1:
2446         if(!def_expire)
2447           BUG();
2448         tty_printf(_("Please specify how long the signature should be valid.\n"
2449                      "         0 = signature does not expire\n"
2450                      "      <n>  = signature expires in n days\n"
2451                      "      <n>w = signature expires in n weeks\n"
2452                      "      <n>m = signature expires in n months\n"
2453                      "      <n>y = signature expires in n years\n"));
2454         break;
2455
2456       default:
2457         BUG();
2458       }
2459
2460     /* Note: The elgamal subkey for DSA has no expiration date because
2461      * it must be signed with the DSA key and this one has the expiration
2462      * date */
2463
2464     answer = NULL;
2465     for(;;)
2466       {
2467         u32 curtime;
2468
2469         xfree(answer);
2470         if(object==0)
2471           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
2472         else
2473           {
2474             char *prompt;
2475
2476             prompt = xasprintf (_("Signature is valid for? (%s) "), def_expire);
2477             answer = cpr_get("siggen.valid",prompt);
2478             xfree(prompt);
2479
2480             if(*answer=='\0')
2481               answer=xstrdup(def_expire);
2482           }
2483         cpr_kill_prompt();
2484         trim_spaces(answer);
2485         curtime = make_timestamp ();
2486         interval = parse_expire_string( answer );
2487         if( interval == (u32)-1 )
2488           {
2489             tty_printf(_("invalid value\n"));
2490             continue;
2491           }
2492
2493         if( !interval )
2494           {
2495             tty_printf((object==0)
2496                        ? _("Key does not expire at all\n")
2497                        : _("Signature does not expire at all\n"));
2498           }
2499         else
2500           {
2501             tty_printf(object==0
2502                        ? _("Key expires at %s\n")
2503                        : _("Signature expires at %s\n"),
2504                        asctimestamp((ulong)(curtime + interval) ) );
2505 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
2506             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2507               tty_printf (_("Your system can't display dates beyond 2038.\n"
2508                             "However, it will be correctly handled up to"
2509                             " 2106.\n"));
2510             else
2511 #endif /*SIZEOF_TIME_T*/
2512               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2513                 {
2514                   tty_printf (_("invalid value\n"));
2515                   continue;
2516                 }
2517           }
2518
2519         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2520                                                    _("Is this correct? (y/N) ")) )
2521           break;
2522       }
2523
2524     xfree(answer);
2525     return interval;
2526 }
2527
2528 u32
2529 ask_expiredate()
2530 {
2531     u32 x = ask_expire_interval(0,NULL);
2532     return x? make_timestamp() + x : 0;
2533 }
2534
2535
2536
2537 static PKT_user_id *
2538 uid_from_string (const char *string)
2539 {
2540   size_t n;
2541   PKT_user_id *uid;
2542
2543   n = strlen (string);
2544   uid = xmalloc_clear (sizeof *uid + n);
2545   uid->len = n;
2546   strcpy (uid->name, string);
2547   uid->ref = 1;
2548   return uid;
2549 }
2550
2551
2552 /* Return true if the user id UID already exists in the keyblock.  */
2553 static int
2554 uid_already_in_keyblock (kbnode_t keyblock, const char *uid)
2555 {
2556   PKT_user_id *uidpkt = uid_from_string (uid);
2557   kbnode_t node;
2558   int result = 0;
2559
2560   for (node=keyblock; node && !result; node=node->next)
2561     if (!is_deleted_kbnode (node)
2562         && node->pkt->pkttype == PKT_USER_ID
2563         && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2564       result = 1;
2565   free_user_id (uidpkt);
2566   return result;
2567 }
2568
2569
2570 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2571    printed for use during a new key creation.  If KEYBLOCK is not NULL
2572    the function prevents the creation of an already existing user
2573    ID.  IF FULL is not set some prompts are not shown.  */
2574 static char *
2575 ask_user_id (int mode, int full, KBNODE keyblock)
2576 {
2577     char *answer;
2578     char *aname, *acomment, *amail, *uid;
2579
2580     if ( !mode )
2581       {
2582         /* TRANSLATORS: This is the new string telling the user what
2583            gpg is now going to do (i.e. ask for the parts of the user
2584            ID).  Note that if you do not translate this string, a
2585            different string will be used, which might still have
2586            a correct translation.  */
2587         const char *s1 =
2588           N_("\n"
2589              "GnuPG needs to construct a user ID to identify your key.\n"
2590              "\n");
2591         const char *s2 = _(s1);
2592
2593         if (!strcmp (s1, s2))
2594           {
2595             /* There is no translation for the string thus we to use
2596                the old info text.  gettext has no way to tell whether
2597                a translation is actually available, thus we need to
2598                to compare again. */
2599             /* TRANSLATORS: This string is in general not anymore used
2600                but you should keep your existing translation.  In case
2601                the new string is not translated this old string will
2602                be used. */
2603             const char *s3 = N_("\n"
2604 "You need a user ID to identify your key; "
2605                                         "the software constructs the user ID\n"
2606 "from the Real Name, Comment and Email Address in this form:\n"
2607 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2608             const char *s4 = _(s3);
2609             if (strcmp (s3, s4))
2610               s2 = s3; /* A translation exists - use it. */
2611           }
2612         tty_printf ("%s", s2) ;
2613       }
2614     uid = aname = acomment = amail = NULL;
2615     for(;;) {
2616         char *p;
2617         int fail=0;
2618
2619         if( !aname ) {
2620             for(;;) {
2621                 xfree(aname);
2622                 aname = cpr_get("keygen.name",_("Real name: "));
2623                 trim_spaces(aname);
2624                 cpr_kill_prompt();
2625
2626                 if( opt.allow_freeform_uid )
2627                     break;
2628
2629                 if( strpbrk( aname, "<>" ) )
2630                   {
2631                     tty_printf(_("Invalid character in name\n"));
2632                     tty_printf(_("The characters '%s' and '%s' may not "
2633                                  "appear in name\n"), "<", ">");
2634                   }
2635                 else if( digitp(aname) )
2636                     tty_printf(_("Name may not start with a digit\n"));
2637                 else if (*aname && strlen (aname) < 5)
2638                   {
2639                     tty_printf(_("Name must be at least 5 characters long\n"));
2640                     /* However, we allow an empty name.  */
2641                   }
2642                 else
2643                     break;
2644             }
2645         }
2646         if( !amail ) {
2647             for(;;) {
2648                 xfree(amail);
2649                 amail = cpr_get("keygen.email",_("Email address: "));
2650                 trim_spaces(amail);
2651                 cpr_kill_prompt();
2652                 if( !*amail || opt.allow_freeform_uid )
2653                     break;   /* no email address is okay */
2654                 else if ( !is_valid_mailbox (amail) )
2655                     tty_printf(_("Not a valid email address\n"));
2656                 else
2657                     break;
2658             }
2659         }
2660         if (!acomment) {
2661           if (full) {
2662             for(;;) {
2663                 xfree(acomment);
2664                 acomment = cpr_get("keygen.comment",_("Comment: "));
2665                 trim_spaces(acomment);
2666                 cpr_kill_prompt();
2667                 if( !*acomment )
2668                     break;   /* no comment is okay */
2669                 else if( strpbrk( acomment, "()" ) )
2670                     tty_printf(_("Invalid character in comment\n"));
2671                 else
2672                     break;
2673             }
2674           }
2675           else {
2676             xfree (acomment);
2677             acomment = xstrdup ("");
2678           }
2679         }
2680
2681
2682         xfree(uid);
2683         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2684         if (!*aname && *amail && !*acomment && !random_is_faked ())
2685           { /* Empty name and comment but with mail address.  Use
2686                simplified form with only the non-angle-bracketed mail
2687                address.  */
2688             p = stpcpy (p, amail);
2689           }
2690         else
2691           {
2692             p = stpcpy (p, aname );
2693             if (*acomment)
2694               p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2695             if (*amail)
2696               p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2697           }
2698
2699         /* Append a warning if the RNG is switched into fake mode.  */
2700         if ( random_is_faked ()  )
2701           strcpy(p, " (insecure!)" );
2702
2703         /* print a note in case that UTF8 mapping has to be done */
2704         for(p=uid; *p; p++ ) {
2705             if( *p & 0x80 ) {
2706                 tty_printf(_("You are using the '%s' character set.\n"),
2707                            get_native_charset() );
2708                 break;
2709             }
2710         }
2711
2712         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2713
2714         if( !*amail && !opt.allow_freeform_uid
2715             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2716             fail = 1;
2717             tty_printf(_("Please don't put the email address "
2718                          "into the real name or the comment\n") );
2719         }
2720
2721         if (!fail && keyblock)
2722           {
2723             if (uid_already_in_keyblock (keyblock, uid))
2724               {
2725                 tty_printf (_("Such a user ID already exists on this key!\n"));
2726                 fail = 1;
2727               }
2728           }
2729
2730         for(;;) {
2731             /* TRANSLATORS: These are the allowed answers in
2732                lower and uppercase.  Below you will find the matching
2733                string which should be translated accordingly and the
2734                letter changed to match the one in the answer string.
2735
2736                  n = Change name
2737                  c = Change comment
2738                  e = Change email
2739                  o = Okay (ready, continue)
2740                  q = Quit
2741              */
2742             const char *ansstr = _("NnCcEeOoQq");
2743
2744             if( strlen(ansstr) != 10 )
2745                 BUG();
2746             if( cpr_enabled() ) {
2747                 answer = xstrdup (ansstr + (fail?8:6));
2748                 answer[1] = 0;
2749             }
2750             else if (full) {
2751                 answer = cpr_get("keygen.userid.cmd", fail?
2752                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2753                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2754                 cpr_kill_prompt();
2755             }
2756             else {
2757                 answer = cpr_get("keygen.userid.cmd", fail?
2758                   _("Change (N)ame, (E)mail, or (Q)uit? ") :
2759                   _("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
2760                 cpr_kill_prompt();
2761             }
2762             if( strlen(answer) > 1 )
2763                 ;
2764             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2765                 xfree(aname); aname = NULL;
2766                 break;
2767             }
2768             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2769                 xfree(acomment); acomment = NULL;
2770                 break;
2771             }
2772             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2773                 xfree(amail); amail = NULL;
2774                 break;
2775             }
2776             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2777                 if( fail ) {
2778                     tty_printf(_("Please correct the error first\n"));
2779                 }
2780                 else {
2781                     xfree(aname); aname = NULL;
2782                     xfree(acomment); acomment = NULL;
2783                     xfree(amail); amail = NULL;
2784                     break;
2785                 }
2786             }
2787             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2788                 xfree(aname); aname = NULL;
2789                 xfree(acomment); acomment = NULL;
2790                 xfree(amail); amail = NULL;
2791                 xfree(uid); uid = NULL;
2792                 break;
2793             }
2794             xfree(answer);
2795         }
2796         xfree(answer);
2797         if (!amail && !acomment)
2798             break;
2799         xfree(uid); uid = NULL;
2800     }
2801     if( uid ) {
2802         char *p = native_to_utf8( uid );
2803         xfree( uid );
2804         uid = p;
2805     }
2806     return uid;
2807 }
2808
2809
2810 /* Basic key generation.  Here we divert to the actual generation
2811    routines based on the requested algorithm.  */
2812 static int
2813 do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
2814            u32 timestamp, u32 expiredate, int is_subkey,
2815            int keygen_flags, const char *passphrase,
2816            char **cache_nonce_addr, char **passwd_nonce_addr)
2817 {
2818   gpg_error_t err;
2819
2820   /* Fixme: The entropy collecting message should be moved to a
2821      libgcrypt progress handler.  */
2822   if (!opt.batch)
2823     tty_printf (_(
2824 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2825 "some other action (type on the keyboard, move the mouse, utilize the\n"
2826 "disks) during the prime generation; this gives the random number\n"
2827 "generator a better chance to gain enough entropy.\n") );
2828
2829   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2830     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2831                    keygen_flags, passphrase,
2832                    cache_nonce_addr, passwd_nonce_addr);
2833   else if (algo == PUBKEY_ALGO_DSA)
2834     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2835                    keygen_flags, passphrase,
2836                    cache_nonce_addr, passwd_nonce_addr);
2837   else if (algo == PUBKEY_ALGO_ECDSA
2838            || algo == PUBKEY_ALGO_EDDSA
2839            || algo == PUBKEY_ALGO_ECDH)
2840     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
2841                    keygen_flags, passphrase,
2842                    cache_nonce_addr, passwd_nonce_addr);
2843   else if (algo == PUBKEY_ALGO_RSA)
2844     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2845                    keygen_flags, passphrase,
2846                    cache_nonce_addr, passwd_nonce_addr);
2847   else
2848     BUG();
2849
2850   return err;
2851 }
2852
2853
2854 /* Generate a new user id packet or return NULL if canceled.  If
2855    KEYBLOCK is not NULL the function prevents the creation of an
2856    already existing user ID.  If UIDSTR is not NULL the user is not
2857    asked but UIDSTR is used to create the user id packet; if the user
2858    id already exists NULL is returned.  UIDSTR is expected to be utf-8
2859    encoded and should have already been checked for a valid length
2860    etc.  */
2861 PKT_user_id *
2862 generate_user_id (KBNODE keyblock, const char *uidstr)
2863 {
2864   PKT_user_id *uid;
2865   char *p;
2866
2867   if (uidstr)
2868     {
2869       if (uid_already_in_keyblock (keyblock, uidstr))
2870         return NULL;  /* Already exists.  */
2871       uid = uid_from_string (uidstr);
2872     }
2873   else
2874     {
2875       p = ask_user_id (1, 1, keyblock);
2876       if (!p)
2877         return NULL;  /* Canceled. */
2878       uid = uid_from_string (p);
2879       xfree (p);
2880     }
2881   return uid;
2882 }
2883
2884
2885 /* Helper for parse_key_parameter_string for one part of the
2886  * specification string; i.e.  ALGO/FLAGS.  If STRING is NULL or empty
2887  * success is returned.  On error an error code is returned.  Note
2888  * that STRING may be modified by this function.  NULL may be passed
2889  * for any parameter.  FOR_SUBKEY shall be true if this is used as a
2890  * subkey.  */
2891 static gpg_error_t
2892 parse_key_parameter_part (char *string, int for_subkey,
2893                           int *r_algo, unsigned int *r_size,
2894                           unsigned int *r_keyuse,
2895                           char const **r_curve)
2896 {
2897   char *flags;
2898   int algo;
2899   char *endp;
2900   const char *curve = NULL;
2901   int ecdh_or_ecdsa = 0;
2902   unsigned int size;
2903   int keyuse;
2904   int i;
2905   const char *s;
2906
2907   if (!string || !*string)
2908     return 0; /* Success.  */
2909
2910   flags = strchr (string, '/');
2911   if (flags)
2912     *flags++ = 0;
2913
2914   algo = 0;
2915   if (strlen (string) >= 3 && (digitp (string+3) || !string[3]))
2916     {
2917       if (!ascii_memcasecmp (string, "rsa", 3))
2918         algo = PUBKEY_ALGO_RSA;
2919       else if (!ascii_memcasecmp (string, "dsa", 3))
2920         algo = PUBKEY_ALGO_DSA;
2921       else if (!ascii_memcasecmp (string, "elg", 3))
2922         algo = PUBKEY_ALGO_ELGAMAL_E;
2923     }
2924   if (algo)
2925     {
2926       if (!string[3])
2927         size = get_keysize_range (algo, NULL, NULL);
2928       else
2929         {
2930           size = strtoul (string+3, &endp, 10);
2931           if (size < 512 || size > 16384 || *endp)
2932             return gpg_error (GPG_ERR_INV_VALUE);
2933         }
2934     }
2935   else if ((curve = openpgp_is_curve_supported (string, &algo, &size)))
2936     {
2937       if (!algo)
2938         {
2939           algo = PUBKEY_ALGO_ECDH; /* Default ECC algorithm.  */
2940           ecdh_or_ecdsa = 1;       /* We may need to switch the algo.  */
2941         }
2942     }
2943   else
2944     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
2945
2946   /* Parse the flags.  */
2947   keyuse = 0;
2948   if (flags)
2949     {
2950       char **tokens = NULL;
2951
2952       tokens = strtokenize (flags, ",");
2953       if (!tokens)
2954         return gpg_error_from_syserror ();
2955
2956       for (i=0; (s = tokens[i]); i++)
2957         {
2958           if (!*s)
2959             ;
2960           else if (!ascii_strcasecmp (s, "sign"))
2961             keyuse |= PUBKEY_USAGE_SIG;
2962           else if (!ascii_strcasecmp (s, "encrypt")
2963                    || !ascii_strcasecmp (s, "encr"))
2964             keyuse |= PUBKEY_USAGE_ENC;
2965           else if (!ascii_strcasecmp (s, "auth"))
2966             keyuse |= PUBKEY_USAGE_AUTH;
2967           else if (!ascii_strcasecmp (s, "cert"))
2968             keyuse |= PUBKEY_USAGE_CERT;
2969           else if (!ascii_strcasecmp (s, "ecdsa"))
2970             {
2971               if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2972                 algo = PUBKEY_ALGO_ECDSA;
2973               else
2974                 {
2975                   xfree (tokens);
2976                   return gpg_error (GPG_ERR_INV_FLAG);
2977                 }
2978               ecdh_or_ecdsa = 0;
2979             }
2980           else if (!ascii_strcasecmp (s, "ecdh"))
2981             {
2982               if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2983                 algo = PUBKEY_ALGO_ECDH;
2984               else
2985                 {
2986                   xfree (tokens);
2987                   return gpg_error (GPG_ERR_INV_FLAG);
2988                 }
2989               ecdh_or_ecdsa = 0;
2990             }
2991           else if (!ascii_strcasecmp (s, "eddsa"))
2992             {
2993               /* Not required but we allow it for consistency.  */
2994               if (algo == PUBKEY_ALGO_EDDSA)
2995                 ;
2996               else
2997                 {
2998                   xfree (tokens);
2999                   return gpg_error (GPG_ERR_INV_FLAG);
3000                 }
3001             }
3002           else
3003             {
3004               xfree (tokens);
3005               return gpg_error (GPG_ERR_UNKNOWN_FLAG);
3006             }
3007         }
3008
3009       xfree (tokens);
3010     }
3011
3012   /* If not yet decided switch between ecdh and ecdsa.  */
3013   if (ecdh_or_ecdsa && keyuse)
3014     algo = (keyuse & PUBKEY_USAGE_ENC)? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_ECDSA;
3015   else if (ecdh_or_ecdsa)
3016     algo = for_subkey? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_ECDSA;
3017
3018   /* Set or fix key usage.  */
3019   if (!keyuse)
3020     {
3021       if (algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_EDDSA
3022           || algo == PUBKEY_ALGO_DSA)
3023         keyuse = PUBKEY_USAGE_SIG;
3024       else if (algo == PUBKEY_ALGO_RSA)
3025         keyuse = for_subkey? PUBKEY_USAGE_ENC : PUBKEY_USAGE_SIG;
3026       else
3027         keyuse = PUBKEY_USAGE_ENC;
3028     }
3029   else if (algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_EDDSA
3030            || algo == PUBKEY_ALGO_DSA)
3031     {
3032       keyuse &= ~PUBKEY_USAGE_ENC; /* Forbid encryption.  */
3033     }
3034   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ELGAMAL_E)
3035     {
3036       keyuse = PUBKEY_USAGE_ENC;   /* Allow only encryption.  */
3037     }
3038
3039   /* Make sure a primary key can certify.  */
3040   if (!for_subkey)
3041     keyuse |= PUBKEY_USAGE_CERT;
3042
3043   /* Check that usage is actually possible.  */
3044   if (/**/((keyuse & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH|PUBKEY_USAGE_CERT))
3045            && !pubkey_get_nsig (algo))
3046        || ((keyuse & PUBKEY_USAGE_ENC)
3047            && !pubkey_get_nenc (algo))
3048        || (for_subkey && (keyuse & PUBKEY_USAGE_CERT)))
3049     return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
3050
3051   /* Return values.  */
3052   if (r_algo)
3053     *r_algo = algo;
3054   if (r_size)
3055     {
3056       unsigned int min, def, max;
3057
3058       /* Make sure the keysize is in the allowed range.  */
3059       def = get_keysize_range (algo, &min, &max);
3060       if (!size)
3061         size = def;
3062       else if (size < min)
3063         size = min;
3064       else if (size > max)
3065         size = max;
3066
3067       *r_size = fixup_keysize (size, algo, 1);
3068     }
3069   if (r_keyuse)
3070     *r_keyuse = keyuse;
3071   if (r_curve)
3072     *r_curve = curve;
3073
3074   return 0;
3075 }
3076
3077 /* Parse and return the standard key generation parameter.
3078  * The string is expected to be in this format:
3079  *
3080  *   ALGO[/FLAGS][+SUBALGO[/FLAGS]]
3081  *
3082  * Here ALGO is a string in the same format as printed by the
3083  * keylisting.  For example:
3084  *
3085  *   rsa3072 := RSA with 3072 bit.
3086  *   dsa2048 := DSA with 2048 bit.
3087  *   elg2048 := Elgamal with 2048 bit.
3088  *   ed25519 := EDDSA using curve Ed25519.
3089  *   cv25519 := ECDH using curve Curve25519.
3090  *   nistp256:= ECDSA or ECDH using curve NIST P-256
3091  *
3092  * All strings with an unknown prefix are considered an elliptic
3093  * curve.  Curves which have no implicit algorithm require that FLAGS
3094  * is given to select whether ECDSA or ECDH is used; this can eoither
3095  * be done using an algorithm keyword or usage keywords.
3096  *
3097  * FLAGS is a comma delimited string of keywords:
3098  *
3099  *   cert := Allow usage Certify
3100  *   sign := Allow usage Sign
3101  *   encr := Allow usage Encrypt
3102  *   auth := Allow usage Authentication
3103  *   encrypt := Alias for "encr"
3104  *   ecdsa := Use algorithm ECDSA.
3105  *   eddsa := Use algorithm EdDSA.
3106  *   ecdh  := Use algorithm ECDH.
3107  *
3108  * There are several defaults and fallbacks depending on the
3109  * algorithm.  PART can be used to select which part of STRING is
3110  * used:
3111  *   -1 := Both parts
3112  *    0 := Only the part of the primary key
3113  *    1 := If there is one part parse that one, if there are
3114  *         two parts parse the second part.  Always return
3115  *         in the args for the primary key (R_ALGO,....).
3116  *
3117  */
3118 gpg_error_t
3119 parse_key_parameter_string (const char *string, int part,
3120                             int *r_algo, unsigned int *r_size,
3121                             unsigned *r_keyuse,
3122                             char const **r_curve,
3123                             int *r_subalgo, unsigned int *r_subsize,
3124                             unsigned *r_subkeyuse,
3125                             char const **r_subcurve)
3126 {
3127   gpg_error_t err = 0;
3128   char *primary, *secondary;
3129
3130   if (r_algo)
3131     *r_algo = 0;
3132   if (r_size)
3133     *r_size = 0;
3134   if (r_keyuse)
3135     *r_keyuse = 0;
3136   if (r_curve)
3137     *r_curve = NULL;
3138   if (r_subalgo)
3139     *r_subalgo = 0;
3140   if (r_subsize)
3141     *r_subsize = 0;
3142   if (r_subkeyuse)
3143     *r_subkeyuse = 0;
3144   if (r_subcurve)
3145     *r_subcurve = NULL;
3146
3147   if (!string || !*string
3148       || !strcmp (string, "default") || !strcmp (string, "-"))
3149     string = get_default_pubkey_algo ();
3150   else if (!strcmp (string, "future-default"))
3151     string = FUTURE_STD_KEY_PARAM;
3152
3153   primary = xstrdup (string);
3154   secondary = strchr (primary, '+');
3155   if (secondary)
3156     *secondary++ = 0;
3157   if (part == -1 || part == 0)
3158     {
3159       err = parse_key_parameter_part (primary, 0, r_algo, r_size,
3160                                       r_keyuse, r_curve);
3161       if (!err && part == -1)
3162         err = parse_key_parameter_part (secondary, 1, r_subalgo, r_subsize,
3163                                         r_subkeyuse, r_subcurve);
3164     }
3165   else if (part == 1)
3166     {
3167       /* If we have SECONDARY, use that part.  If there is only one
3168        * part consider this to be the subkey algo.  */
3169       err = parse_key_parameter_part (secondary? secondary : primary, 1,
3170                                       r_algo, r_size, r_keyuse, r_curve);
3171     }
3172
3173   xfree (primary);
3174
3175   return err;
3176 }
3177
3178
3179
3180 /* Append R to the linked list PARA.  */
3181 static void
3182 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
3183 {
3184   log_assert (para);
3185   while (para->next)
3186     para = para->next;
3187   para->next = r;
3188 }
3189
3190 /* Release the parameter list R.  */
3191 static void
3192 release_parameter_list (struct para_data_s *r)
3193 {
3194   struct para_data_s *r2;
3195
3196   for (; r ; r = r2)
3197     {
3198       r2 = r->next;
3199       if (r->key == pPASSPHRASE && *r->u.value)
3200         wipememory (r->u.value, strlen (r->u.value));
3201       xfree (r);
3202     }
3203 }
3204
3205 static struct para_data_s *
3206 get_parameter( struct para_data_s *para, enum para_name key )
3207 {
3208     struct para_data_s *r;
3209
3210     for( r = para; r && r->key != key; r = r->next )
3211         ;
3212     return r;
3213 }
3214
3215 static const char *
3216 get_parameter_value( struct para_data_s *para, enum para_name key )
3217 {
3218     struct para_data_s *r = get_parameter( para, key );
3219     return (r && *r->u.value)? r->u.value : NULL;
3220 }
3221
3222
3223 /* This is similar to get_parameter_value but also returns the empty
3224    string.  This is required so that quick_generate_keypair can use an
3225    empty Passphrase to specify no-protection.  */
3226 static const char *
3227 get_parameter_passphrase (struct para_data_s *para)
3228 {
3229   struct para_data_s *r = get_parameter (para, pPASSPHRASE);
3230   return r ? r->u.value : NULL;
3231 }
3232
3233
3234 static int
3235 get_parameter_algo( struct para_data_s *para, enum para_name key,
3236                     int *r_default)
3237 {
3238   int i;
3239   struct para_data_s *r = get_parameter( para, key );
3240
3241   if (r_default)
3242     *r_default = 0;
3243
3244   if (!r)
3245     return -1;
3246
3247   /* Note that we need to handle the ECC algorithms specified as
3248      strings directly because Libgcrypt folds them all to ECC.  */
3249   if (!ascii_strcasecmp (r->u.value, "default"))
3250     {
3251       /* Note: If you change this default algo, remember to change it
3252        * also in gpg.c:gpgconf_list.  */
3253       /* FIXME: We only allow the algo here and have a separate thing
3254        * for the curve etc.  That is a ugly but demanded for backward
3255        * compatibility with the batch key generation.  It would be
3256        * better to make full use of parse_key_parameter_string.  */
3257       parse_key_parameter_string (NULL, 0,
3258                                   &i, NULL, NULL, NULL,
3259                                   NULL, NULL, NULL, NULL);
3260
3261       if (r_default)
3262         *r_default = 1;
3263     }
3264   else if (digitp (r->u.value))
3265     i = atoi( r->u.value );
3266   else if (!strcmp (r->u.value, "ELG-E")
3267            || !strcmp (r->u.value, "ELG"))
3268     i = PUBKEY_ALGO_ELGAMAL_E;
3269   else if (!ascii_strcasecmp (r->u.value, "EdDSA"))
3270     i = PUBKEY_ALGO_EDDSA;
3271   else if (!ascii_strcasecmp (r->u.value, "ECDSA"))
3272     i = PUBKEY_ALGO_ECDSA;
3273   else if (!ascii_strcasecmp (r->u.value, "ECDH"))
3274     i = PUBKEY_ALGO_ECDH;
3275   else
3276     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
3277
3278   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
3279     i = 0; /* we don't want to allow generation of these algorithms */
3280   return i;
3281 }
3282
3283
3284 /* Parse a usage string.  The usage keywords "auth", "sign", "encr"
3285  * may be delimited by space, tab, or comma.  On error -1 is returned
3286  * instead of the usage flags.  */
3287 static int
3288 parse_usagestr (const char *usagestr)
3289 {
3290   gpg_error_t err;
3291   char **tokens = NULL;
3292   const char *s;
3293   int i;
3294   unsigned int use = 0;
3295
3296   tokens = strtokenize (usagestr, " \t,");
3297   if (!tokens)
3298     {
3299       err = gpg_error_from_syserror ();
3300       log_error ("strtokenize failed: %s\n", gpg_strerror (err));
3301       return -1;
3302     }
3303
3304   for (i=0; (s = tokens[i]); i++)
3305     {
3306       if (!*s)
3307         ;
3308       else if (!ascii_strcasecmp (s, "sign"))
3309         use |= PUBKEY_USAGE_SIG;
3310       else if (!ascii_strcasecmp (s, "encrypt")
3311                 || !ascii_strcasecmp (s, "encr"))
3312         use |= PUBKEY_USAGE_ENC;
3313       else if (!ascii_strcasecmp (s, "auth"))
3314         use |= PUBKEY_USAGE_AUTH;
3315       else if (!ascii_strcasecmp (s, "cert"))
3316         use |= PUBKEY_USAGE_CERT;
3317       else
3318         {
3319           xfree (tokens);
3320           return -1; /* error */
3321         }
3322     }
3323
3324   xfree (tokens);
3325   return use;
3326 }
3327
3328
3329 /*
3330  * Parse the usage parameter and set the keyflags.  Returns -1 on
3331  * error, 0 for no usage given or 1 for usage available.
3332  */
3333 static int
3334 parse_parameter_usage (const char *fname,
3335                        struct para_data_s *para, enum para_name key)
3336 {
3337   struct para_data_s *r = get_parameter( para, key );
3338   int i;
3339
3340   if (!r)
3341     return 0; /* none (this is an optional parameter)*/
3342
3343   i = parse_usagestr (r->u.value);
3344   if (i == -1)
3345     {
3346       log_error ("%s:%d: invalid usage list\n", fname, r->lnr );
3347       return -1; /* error */
3348     }
3349
3350   r->u.usage = i;
3351   return 1;
3352 }
3353
3354
3355 static int
3356 parse_revocation_key (const char *fname,
3357                       struct para_data_s *para, enum para_name key)
3358 {
3359   struct para_data_s *r = get_parameter( para, key );
3360   struct revocation_key revkey;
3361   char *pn;
3362   int i;
3363
3364   if( !r )
3365     return 0; /* none (this is an optional parameter) */
3366
3367   pn = r->u.value;
3368
3369   revkey.class=0x80;
3370   revkey.algid=atoi(pn);
3371   if(!revkey.algid)
3372     goto fail;
3373
3374   /* Skip to the fpr */
3375   while(*pn && *pn!=':')
3376     pn++;
3377
3378   if(*pn!=':')
3379     goto fail;
3380
3381   pn++;
3382
3383   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
3384     {
3385       int c=hextobyte(pn);
3386       if(c==-1)
3387         goto fail;
3388
3389       revkey.fpr[i]=c;
3390     }
3391
3392   /* skip to the tag */
3393   while(*pn && *pn!='s' && *pn!='S')
3394     pn++;
3395
3396   if(ascii_strcasecmp(pn,"sensitive")==0)
3397     revkey.class|=0x40;
3398
3399   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
3400
3401   return 0;
3402
3403   fail:
3404   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
3405   return -1; /* error */
3406 }
3407
3408
3409 static u32
3410 get_parameter_u32( struct para_data_s *para, enum para_name key )
3411 {
3412   struct para_data_s *r = get_parameter( para, key );
3413
3414   if( !r )
3415     return 0;
3416   if( r->key == pKEYCREATIONDATE )
3417     return r->u.creation;
3418   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
3419     return r->u.expire;
3420   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
3421     return r->u.usage;
3422
3423   return (unsigned int)strtoul( r->u.value, NULL, 10 );
3424 }
3425
3426 static unsigned int
3427 get_parameter_uint( struct para_data_s *para, enum para_name key )
3428 {
3429     return get_parameter_u32( para, key );
3430 }
3431
3432 static struct revocation_key *
3433 get_parameter_revkey( struct para_data_s *para, enum para_name key )
3434 {
3435     struct para_data_s *r = get_parameter( para, key );
3436     return r? &r->u.revkey : NULL;
3437 }
3438
3439 static int
3440 proc_parameter_file (ctrl_t ctrl, struct para_data_s *para, const char *fname,
3441                      struct output_control_s *outctrl, int card )
3442 {
3443   struct para_data_s *r;
3444   const char *s1, *s2, *s3;
3445   size_t n;
3446   char *p;
3447   int is_default = 0;
3448   int have_user_id = 0;
3449   int err, algo;
3450
3451   /* Check that we have all required parameters. */
3452   r = get_parameter( para, pKEYTYPE );
3453   if(r)
3454     {
3455       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
3456       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
3457         {
3458           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3459           return -1;
3460         }
3461     }
3462   else
3463     {
3464       log_error ("%s: no Key-Type specified\n",fname);
3465       return -1;
3466     }
3467
3468   err = parse_parameter_usage (fname, para, pKEYUSAGE);
3469   if (!err)
3470     {
3471       /* Default to algo capabilities if key-usage is not provided and
3472          no default algorithm has been requested.  */
3473       r = xmalloc_clear(sizeof(*r));
3474       r->key = pKEYUSAGE;
3475       r->u.usage = (is_default
3476                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
3477                     : openpgp_pk_algo_usage(algo));
3478       append_to_parameter (para, r);
3479     }
3480   else if (err == -1)
3481     return -1;
3482   else
3483     {
3484       r = get_parameter (para, pKEYUSAGE);
3485       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3486         {
3487           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
3488                      fname, r->lnr, algo);
3489           return -1;
3490         }
3491     }
3492
3493   is_default = 0;
3494   r = get_parameter( para, pSUBKEYTYPE );
3495   if(r)
3496     {
3497       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
3498       if (openpgp_pk_test_algo (algo))
3499         {
3500           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3501           return -1;
3502         }
3503
3504       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
3505       if (!err)
3506         {
3507           /* Default to algo capabilities if subkey-usage is not
3508              provided */
3509           r = xmalloc_clear (sizeof(*r));
3510           r->key = pSUBKEYUSAGE;
3511           r->u.usage = (is_default
3512                         ? PUBKEY_USAGE_ENC
3513                         : openpgp_pk_algo_usage (algo));
3514           append_to_parameter (para, r);
3515         }
3516       else if (err == -1)
3517         return -1;
3518       else
3519         {
3520           r = get_parameter (para, pSUBKEYUSAGE);
3521           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3522             {
3523               log_error ("%s:%d: specified Subkey-Usage not allowed"
3524                          " for algo %d\n", fname, r->lnr, algo);
3525               return -1;
3526             }
3527         }
3528     }
3529
3530
3531   if( get_parameter_value( para, pUSERID ) )
3532     have_user_id=1;
3533   else
3534     {
3535       /* create the formatted user ID */
3536       s1 = get_parameter_value( para, pNAMEREAL );
3537       s2 = get_parameter_value( para, pNAMECOMMENT );
3538       s3 = get_parameter_value( para, pNAMEEMAIL );
3539       if( s1 || s2 || s3 )
3540         {
3541           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
3542           r = xmalloc_clear( sizeof *r + n + 20 );
3543           r->key = pUSERID;
3544           p = r->u.value;
3545           if( s1 )
3546             p = stpcpy(p, s1 );
3547           if( s2 )
3548             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
3549           if( s3 )
3550             {
3551               /* If we have only the email part, do not add the space
3552                * and the angle brackets.  */
3553               if (*r->u.value)
3554                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
3555               else
3556                 p = stpcpy (p, s3);
3557             }
3558           append_to_parameter (para, r);
3559           have_user_id=1;
3560         }
3561     }
3562
3563   if(!have_user_id)
3564     {
3565       log_error("%s: no User-ID specified\n",fname);
3566       return -1;
3567     }
3568
3569   /* Set preferences, if any. */
3570   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
3571
3572   /* Set keyserver, if any. */
3573   s1=get_parameter_value( para, pKEYSERVER );
3574   if(s1)
3575     {
3576       struct keyserver_spec *spec;
3577
3578       spec = parse_keyserver_uri (s1, 1);
3579       if(spec)
3580         {
3581           free_keyserver_spec(spec);
3582           opt.def_keyserver_url=s1;
3583         }
3584       else
3585         {
3586           r = get_parameter (para, pKEYSERVER);
3587           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
3588           return -1;
3589         }
3590     }
3591
3592   /* Set revoker, if any. */
3593   if (parse_revocation_key (fname, para, pREVOKER))
3594     return -1;
3595
3596
3597   /* Make KEYCREATIONDATE from Creation-Date.  */
3598   r = get_parameter (para, pCREATIONDATE);
3599   if (r && *r->u.value)
3600     {
3601       u32 seconds;
3602
3603       seconds = parse_creation_string (r->u.value);
3604       if (!seconds)
3605         {
3606           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
3607           return -1;
3608         }
3609       r->u.creation = seconds;
3610       r->key = pKEYCREATIONDATE;  /* Change that entry. */
3611     }
3612
3613   /* Make KEYEXPIRE from Expire-Date.  */
3614   r = get_parameter( para, pEXPIREDATE );
3615   if( r && *r->u.value )
3616     {
3617       u32 seconds;
3618
3619       seconds = parse_expire_string( r->u.value );
3620       if( seconds == (u32)-1 )
3621         {
3622           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
3623           return -1;
3624         }
3625       r->u.expire = seconds;
3626       r->key = pKEYEXPIRE;  /* change hat entry */
3627       /* also set it for the subkey */
3628       r = xmalloc_clear( sizeof *r + 20 );
3629       r->key = pSUBKEYEXPIRE;
3630       r->u.expire = seconds;
3631       append_to_parameter (para, r);
3632     }
3633
3634   do_generate_keypair (ctrl, para, outctrl, card );
3635   return 0;
3636 }
3637
3638
3639 /****************
3640  * Kludge to allow non interactive key generation controlled
3641  * by a parameter file.
3642  * Note, that string parameters are expected to be in UTF-8
3643  */
3644 static void
3645 read_parameter_file (ctrl_t ctrl, const char *fname )
3646 {
3647     static struct { const char *name;
3648                     enum para_name key;
3649     } keywords[] = {
3650         { "Key-Type",       pKEYTYPE},
3651         { "Key-Length",     pKEYLENGTH },
3652         { "Key-Curve",      pKEYCURVE },
3653         { "Key-Usage",      pKEYUSAGE },
3654         { "Subkey-Type",    pSUBKEYTYPE },