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