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