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