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