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