gpg: New option --override-session-key-fd.
[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 && opt.compliance != CO_DE_VS)
1889     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1890
1891   if (opt.compliance != CO_DE_VS)
1892     tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1893 #if GPG_USE_RSA
1894   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1895 #endif
1896
1897   if (addmode)
1898     {
1899       if (opt.compliance != CO_DE_VS)
1900         tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1901 #if GPG_USE_RSA
1902       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1903 #endif
1904     }
1905   if (opt.expert)
1906     {
1907       if (opt.compliance != CO_DE_VS)
1908         tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1909 #if GPG_USE_RSA
1910       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1911 #endif
1912     }
1913
1914 #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
1915   if (opt.expert && !addmode)
1916     tty_printf (_("   (%d) ECC and ECC\n"), 9 );
1917   if (opt.expert)
1918     tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
1919   if (opt.expert)
1920     tty_printf (_("  (%d) ECC (set your own capabilities)\n"), 11 );
1921   if (opt.expert && addmode)
1922     tty_printf (_("  (%d) ECC (encrypt only)\n"), 12 );
1923 #endif
1924
1925   if (opt.expert && r_keygrip)
1926     tty_printf (_("  (%d) Existing key\n"), 13 );
1927
1928   for (;;)
1929     {
1930       *r_usage = 0;
1931       *r_subkey_algo = 0;
1932       xfree (answer);
1933       answer = cpr_get ("keygen.algo", _("Your selection? "));
1934       cpr_kill_prompt ();
1935       algo = *answer? atoi (answer) : 1;
1936
1937       if (opt.compliance == CO_DE_VS
1938           && (algo == 2 || algo == 3 || algo == 5 || algo == 7))
1939         {
1940           tty_printf (_("Invalid selection.\n"));
1941         }
1942       else if ((algo == 1 || !strcmp (answer, "rsa+rsa")) && !addmode)
1943         {
1944           algo = PUBKEY_ALGO_RSA;
1945           *r_subkey_algo = PUBKEY_ALGO_RSA;
1946           break;
1947         }
1948       else if ((algo == 2 || !strcmp (answer, "dsa+elg")) && !addmode)
1949         {
1950           algo = PUBKEY_ALGO_DSA;
1951           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1952           break;
1953         }
1954       else if (algo == 3 || !strcmp (answer, "dsa"))
1955         {
1956           algo = PUBKEY_ALGO_DSA;
1957           *r_usage = PUBKEY_USAGE_SIG;
1958           break;
1959         }
1960       else if (algo == 4 || !strcmp (answer, "rsa/s"))
1961         {
1962           algo = PUBKEY_ALGO_RSA;
1963           *r_usage = PUBKEY_USAGE_SIG;
1964           break;
1965         }
1966       else if ((algo == 5 || !strcmp (answer, "elg")) && addmode)
1967         {
1968           algo = PUBKEY_ALGO_ELGAMAL_E;
1969           *r_usage = PUBKEY_USAGE_ENC;
1970           break;
1971         }
1972       else if ((algo == 6 || !strcmp (answer, "rsa/e")) && addmode)
1973         {
1974           algo = PUBKEY_ALGO_RSA;
1975           *r_usage = PUBKEY_USAGE_ENC;
1976           break;
1977         }
1978       else if ((algo == 7 || !strcmp (answer, "dsa/*")) && opt.expert)
1979         {
1980           algo = PUBKEY_ALGO_DSA;
1981           *r_usage = ask_key_flags (algo, addmode, 0);
1982           break;
1983         }
1984       else if ((algo == 8 || !strcmp (answer, "rsa/*")) && opt.expert)
1985         {
1986           algo = PUBKEY_ALGO_RSA;
1987           *r_usage = ask_key_flags (algo, addmode, 0);
1988           break;
1989         }
1990       else if ((algo == 9 || !strcmp (answer, "ecc+ecc"))
1991                && opt.expert && !addmode)
1992         {
1993           algo = PUBKEY_ALGO_ECDSA;
1994           *r_subkey_algo = PUBKEY_ALGO_ECDH;
1995           break;
1996         }
1997       else if ((algo == 10 || !strcmp (answer, "ecc/s")) && opt.expert)
1998         {
1999           algo = PUBKEY_ALGO_ECDSA;
2000           *r_usage = PUBKEY_USAGE_SIG;
2001           break;
2002         }
2003       else if ((algo == 11 || !strcmp (answer, "ecc/*")) && opt.expert)
2004         {
2005           algo = PUBKEY_ALGO_ECDSA;
2006           *r_usage = ask_key_flags (algo, addmode, 0);
2007           break;
2008         }
2009       else if ((algo == 12 || !strcmp (answer, "ecc/e"))
2010                && opt.expert && addmode)
2011         {
2012           algo = PUBKEY_ALGO_ECDH;
2013           *r_usage = PUBKEY_USAGE_ENC;
2014           break;
2015         }
2016       else if ((algo == 13 || !strcmp (answer, "keygrip"))
2017                && opt.expert && r_keygrip)
2018         {
2019           for (;;)
2020             {
2021               xfree (answer);
2022               answer = tty_get (_("Enter the keygrip: "));
2023               tty_kill_prompt ();
2024               trim_spaces (answer);
2025               if (!*answer)
2026                 {
2027                   xfree (answer);
2028                   answer = NULL;
2029                   continue;
2030                 }
2031
2032               if (strlen (answer) != 40 &&
2033                        !(answer[0] == '&' && strlen (answer+1) == 40))
2034                 tty_printf
2035                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
2036               else if (!(algo = check_keygrip (ctrl, answer)) )
2037                 tty_printf (_("No key with this keygrip\n"));
2038               else
2039                 break; /* Okay.  */
2040             }
2041           xfree (keygrip);
2042           keygrip = answer;
2043           answer = NULL;
2044           *r_usage = ask_key_flags (algo, addmode, 0);
2045           break;
2046         }
2047       else
2048         tty_printf (_("Invalid selection.\n"));
2049
2050     }
2051
2052   xfree(answer);
2053   if (r_keygrip)
2054     *r_keygrip = keygrip;
2055   return algo;
2056 }
2057
2058
2059 static void
2060 get_keysize_range (int algo,
2061                    unsigned int *min, unsigned int *def, unsigned int *max)
2062 {
2063   *min = opt.compliance == CO_DE_VS ? 2048: 1024;
2064   *def = DEFAULT_STD_KEYSIZE;
2065   *max = 4096;
2066
2067   /* Deviations from the standard values.  */
2068   switch(algo)
2069     {
2070     case PUBKEY_ALGO_DSA:
2071       *min = opt.expert? 768 : 1024;
2072       *def=2048;
2073       *max=3072;
2074       break;
2075
2076     case PUBKEY_ALGO_ECDSA:
2077     case PUBKEY_ALGO_ECDH:
2078       *min=256;
2079       *def=256;
2080       *max=521;
2081       break;
2082
2083     case PUBKEY_ALGO_EDDSA:
2084       *min=255;
2085       *def=255;
2086       *max=441;
2087       break;
2088     }
2089 }
2090
2091
2092 /* Return a fixed up keysize depending on ALGO.  */
2093 static unsigned int
2094 fixup_keysize (unsigned int nbits, int algo, int silent)
2095 {
2096   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
2097     {
2098       nbits = ((nbits + 63) / 64) * 64;
2099       if (!silent)
2100         tty_printf (_("rounded up to %u bits\n"), nbits);
2101     }
2102   else if (algo == PUBKEY_ALGO_EDDSA)
2103     {
2104       if (nbits != 255 && nbits != 441)
2105         {
2106           if (nbits < 256)
2107             nbits = 255;
2108           else
2109             nbits = 441;
2110           if (!silent)
2111             tty_printf (_("rounded to %u bits\n"), nbits);
2112         }
2113     }
2114   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2115     {
2116       if (nbits != 256 && nbits != 384 && nbits != 521)
2117         {
2118           if (nbits < 256)
2119             nbits = 256;
2120           else if (nbits < 384)
2121             nbits = 384;
2122           else
2123             nbits = 521;
2124           if (!silent)
2125             tty_printf (_("rounded to %u bits\n"), nbits);
2126         }
2127     }
2128   else if ((nbits % 32))
2129     {
2130       nbits = ((nbits + 31) / 32) * 32;
2131       if (!silent)
2132         tty_printf (_("rounded up to %u bits\n"), nbits );
2133     }
2134
2135   return nbits;
2136 }
2137
2138
2139 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
2140    is not 0, the function asks for the size of the encryption
2141    subkey. */
2142 static unsigned
2143 ask_keysize (int algo, unsigned int primary_keysize)
2144 {
2145   unsigned int nbits;
2146   unsigned int min, def, max;
2147   int for_subkey = !!primary_keysize;
2148   int autocomp = 0;
2149
2150   get_keysize_range (algo, &min, &def, &max);
2151
2152   if (primary_keysize && !opt.expert)
2153     {
2154       /* Deduce the subkey size from the primary key size.  */
2155       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
2156         nbits = 3072; /* For performance reasons we don't support more
2157                          than 3072 bit DSA.  However we won't see this
2158                          case anyway because DSA can't be used as an
2159                          encryption subkey ;-). */
2160       else
2161         nbits = primary_keysize;
2162       autocomp = 1;
2163       goto leave;
2164     }
2165
2166   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
2167              openpgp_pk_algo_name (algo), min, max);
2168
2169   for (;;)
2170     {
2171       char *prompt, *answer;
2172
2173       if (for_subkey)
2174         prompt = xasprintf (_("What keysize do you want "
2175                               "for the subkey? (%u) "), def);
2176       else
2177         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
2178       answer = cpr_get ("keygen.size", prompt);
2179       cpr_kill_prompt ();
2180       nbits = *answer? atoi (answer): def;
2181       xfree(prompt);
2182       xfree(answer);
2183
2184       if(nbits<min || nbits>max)
2185         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
2186                    openpgp_pk_algo_name (algo), min, max);
2187       else
2188         break;
2189     }
2190
2191   tty_printf (_("Requested keysize is %u bits\n"), nbits);
2192
2193  leave:
2194   nbits = fixup_keysize (nbits, algo, autocomp);
2195   return nbits;
2196 }
2197
2198
2199 /* Ask for the curve.  ALGO is the selected algorithm which this
2200    function may adjust.  Returns a malloced string with the name of
2201    the curve.  BOTH tells that gpg creates a primary and subkey. */
2202 static char *
2203 ask_curve (int *algo, int *subkey_algo)
2204 {
2205   /* NB: We always use a complete algo list so that we have stable
2206      numbers in the menu regardless on how Gpg was configured.  */
2207   struct {
2208     const char *name;
2209     const char* eddsa_curve; /* Corresponding EdDSA curve.  */
2210     const char *pretty_name;
2211     unsigned int supported : 1;   /* Supported by gpg.     */
2212     unsigned int de_vs : 1;       /* Allowed in CO_DE_VS.  */
2213     unsigned int expert_only : 1; /* Only with --expert    */
2214     unsigned int available : 1;   /* Available in Libycrypt (runtime checked) */
2215   } curves[] = {
2216 #if GPG_USE_ECDSA || GPG_USE_ECDH
2217 # define MY_USE_ECDSADH 1
2218 #else
2219 # define MY_USE_ECDSADH 0
2220 #endif
2221     { "Curve25519",      "Ed25519", "Curve 25519", !!GPG_USE_EDDSA, 0, 0, 0 },
2222     { "Curve448",        "Ed448",   "Curve 448",   0/*reserved*/  , 0, 1, 0 },
2223     { "NIST P-256",      NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2224     { "NIST P-384",      NULL, NULL,               MY_USE_ECDSADH,  0, 0, 0 },
2225     { "NIST P-521",      NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2226     { "brainpoolP256r1", NULL, "Brainpool P-256",  MY_USE_ECDSADH,  1, 1, 0 },
2227     { "brainpoolP384r1", NULL, "Brainpool P-384",  MY_USE_ECDSADH,  1, 1, 0 },
2228     { "brainpoolP512r1", NULL, "Brainpool P-512",  MY_USE_ECDSADH,  1, 1, 0 },
2229     { "secp256k1",       NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2230   };
2231 #undef MY_USE_ECDSADH
2232   int idx;
2233   char *answer;
2234   char *result = NULL;
2235   gcry_sexp_t keyparms;
2236
2237   tty_printf (_("Please select which elliptic curve you want:\n"));
2238
2239   keyparms = NULL;
2240   for (idx=0; idx < DIM(curves); idx++)
2241     {
2242       int rc;
2243
2244       curves[idx].available = 0;
2245       if (!curves[idx].supported)
2246         continue;
2247
2248       if (opt.compliance==CO_DE_VS)
2249         {
2250           if (!curves[idx].de_vs)
2251             continue; /* Not allowed.  */
2252         }
2253       else if (!opt.expert && curves[idx].expert_only)
2254         continue;
2255
2256       /* We need to switch from the ECDH name of the curve to the
2257          EDDSA name of the curve if we want a signing key.  */
2258       gcry_sexp_release (keyparms);
2259       rc = gcry_sexp_build (&keyparms, NULL,
2260                             "(public-key(ecc(curve %s)))",
2261                             curves[idx].eddsa_curve? curves[idx].eddsa_curve
2262                             /**/                   : curves[idx].name);
2263       if (rc)
2264         continue;
2265       if (!gcry_pk_get_curve (keyparms, 0, NULL))
2266         continue;
2267       if (subkey_algo && curves[idx].eddsa_curve)
2268         {
2269           /* Both Curve 25519 (or 448) keys are to be created.  Check that
2270              Libgcrypt also supports the real Curve25519 (or 448).  */
2271           gcry_sexp_release (keyparms);
2272           rc = gcry_sexp_build (&keyparms, NULL,
2273                                 "(public-key(ecc(curve %s)))",
2274                                  curves[idx].name);
2275           if (rc)
2276             continue;
2277           if (!gcry_pk_get_curve (keyparms, 0, NULL))
2278             continue;
2279         }
2280
2281       curves[idx].available = 1;
2282       tty_printf ("   (%d) %s\n", idx + 1,
2283                   curves[idx].pretty_name?
2284                   curves[idx].pretty_name:curves[idx].name);
2285     }
2286   gcry_sexp_release (keyparms);
2287
2288
2289   for (;;)
2290     {
2291       answer = cpr_get ("keygen.curve", _("Your selection? "));
2292       cpr_kill_prompt ();
2293       idx = *answer? atoi (answer) : 1;
2294       if (*answer && !idx)
2295         {
2296           /* See whether the user entered the name of the curve.  */
2297           for (idx=0; idx < DIM(curves); idx++)
2298             {
2299               if (!opt.expert && curves[idx].expert_only)
2300                 continue;
2301               if (!stricmp (curves[idx].name, answer)
2302                   || (curves[idx].pretty_name
2303                       && !stricmp (curves[idx].pretty_name, answer)))
2304                 break;
2305             }
2306           if (idx == DIM(curves))
2307             idx = -1;
2308         }
2309       else
2310         idx--;
2311       xfree(answer);
2312       answer = NULL;
2313       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
2314         tty_printf (_("Invalid selection.\n"));
2315       else
2316         {
2317           /* If the user selected a signing algorithm and Curve25519
2318              we need to set the algo to EdDSA and update the curve name. */
2319           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
2320               && curves[idx].eddsa_curve)
2321             {
2322               if (subkey_algo && *subkey_algo == PUBKEY_ALGO_ECDSA)
2323                 *subkey_algo = PUBKEY_ALGO_EDDSA;
2324               *algo = PUBKEY_ALGO_EDDSA;
2325               result = xstrdup (curves[idx].eddsa_curve);
2326             }
2327           else
2328             result = xstrdup (curves[idx].name);
2329           break;
2330         }
2331     }
2332
2333   if (!result)
2334     result = xstrdup (curves[0].name);
2335
2336   return result;
2337 }
2338
2339
2340 /****************
2341  * Parse an expire string and return its value in seconds.
2342  * Returns (u32)-1 on error.
2343  * This isn't perfect since scan_isodatestr returns unix time, and
2344  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
2345  * Because of this, we only permit setting expirations up to 2106, but
2346  * OpenPGP could theoretically allow up to 2242.  I think we'll all
2347  * just cope for the next few years until we get a 64-bit time_t or
2348  * similar.
2349  */
2350 u32
2351 parse_expire_string( const char *string )
2352 {
2353   int mult;
2354   u32 seconds;
2355   u32 abs_date = 0;
2356   u32 curtime = make_timestamp ();
2357   time_t tt;
2358
2359   if (!string || !*string || !strcmp (string, "none")
2360       || !strcmp (string, "never") || !strcmp (string, "-"))
2361     seconds = 0;
2362   else if (!strncmp (string, "seconds=", 8))
2363     seconds = atoi (string+8);
2364   else if ((abs_date = scan_isodatestr(string))
2365            && (abs_date+86400/2) > curtime)
2366     seconds = (abs_date+86400/2) - curtime;
2367   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
2368     seconds = (u32)tt - curtime;
2369   else if ((mult = check_valid_days (string)))
2370     seconds = atoi (string) * 86400L * mult;
2371   else
2372     seconds = (u32)(-1);
2373
2374   return seconds;
2375 }
2376
2377 /* Parse a Creation-Date string which is either "1986-04-26" or
2378    "19860426T042640".  Returns 0 on error. */
2379 static u32
2380 parse_creation_string (const char *string)
2381 {
2382   u32 seconds;
2383
2384   if (!*string)
2385     seconds = 0;
2386   else if ( !strncmp (string, "seconds=", 8) )
2387     seconds = atoi (string+8);
2388   else if ( !(seconds = scan_isodatestr (string)))
2389     {
2390       time_t tmp = isotime2epoch (string);
2391       seconds = (tmp == (time_t)(-1))? 0 : tmp;
2392     }
2393   return seconds;
2394 }
2395
2396
2397 /* object == 0 for a key, and 1 for a sig */
2398 u32
2399 ask_expire_interval(int object,const char *def_expire)
2400 {
2401     u32 interval;
2402     char *answer;
2403
2404     switch(object)
2405       {
2406       case 0:
2407         if(def_expire)
2408           BUG();
2409         tty_printf(_("Please specify how long the key should be valid.\n"
2410                      "         0 = key does not expire\n"
2411                      "      <n>  = key expires in n days\n"
2412                      "      <n>w = key expires in n weeks\n"
2413                      "      <n>m = key expires in n months\n"
2414                      "      <n>y = key expires in n years\n"));
2415         break;
2416
2417       case 1:
2418         if(!def_expire)
2419           BUG();
2420         tty_printf(_("Please specify how long the signature should be valid.\n"
2421                      "         0 = signature does not expire\n"
2422                      "      <n>  = signature expires in n days\n"
2423                      "      <n>w = signature expires in n weeks\n"
2424                      "      <n>m = signature expires in n months\n"
2425                      "      <n>y = signature expires in n years\n"));
2426         break;
2427
2428       default:
2429         BUG();
2430       }
2431
2432     /* Note: The elgamal subkey for DSA has no expiration date because
2433      * it must be signed with the DSA key and this one has the expiration
2434      * date */
2435
2436     answer = NULL;
2437     for(;;)
2438       {
2439         u32 curtime;
2440
2441         xfree(answer);
2442         if(object==0)
2443           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
2444         else
2445           {
2446             char *prompt;
2447
2448             prompt = xasprintf (_("Signature is valid for? (%s) "), def_expire);
2449             answer = cpr_get("siggen.valid",prompt);
2450             xfree(prompt);
2451
2452             if(*answer=='\0')
2453               answer=xstrdup(def_expire);
2454           }
2455         cpr_kill_prompt();
2456         trim_spaces(answer);
2457         curtime = make_timestamp ();
2458         interval = parse_expire_string( answer );
2459         if( interval == (u32)-1 )
2460           {
2461             tty_printf(_("invalid value\n"));
2462             continue;
2463           }
2464
2465         if( !interval )
2466           {
2467             tty_printf((object==0)
2468                        ? _("Key does not expire at all\n")
2469                        : _("Signature does not expire at all\n"));
2470           }
2471         else
2472           {
2473             tty_printf(object==0
2474                        ? _("Key expires at %s\n")
2475                        : _("Signature expires at %s\n"),
2476                        asctimestamp((ulong)(curtime + interval) ) );
2477 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
2478             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2479               tty_printf (_("Your system can't display dates beyond 2038.\n"
2480                             "However, it will be correctly handled up to"
2481                             " 2106.\n"));
2482             else
2483 #endif /*SIZEOF_TIME_T*/
2484               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2485                 {
2486                   tty_printf (_("invalid value\n"));
2487                   continue;
2488                 }
2489           }
2490
2491         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2492                                                    _("Is this correct? (y/N) ")) )
2493           break;
2494       }
2495
2496     xfree(answer);
2497     return interval;
2498 }
2499
2500 u32
2501 ask_expiredate()
2502 {
2503     u32 x = ask_expire_interval(0,NULL);
2504     return x? make_timestamp() + x : 0;
2505 }
2506
2507
2508
2509 static PKT_user_id *
2510 uid_from_string (const char *string)
2511 {
2512   size_t n;
2513   PKT_user_id *uid;
2514
2515   n = strlen (string);
2516   uid = xmalloc_clear (sizeof *uid + n);
2517   uid->len = n;
2518   strcpy (uid->name, string);
2519   uid->ref = 1;
2520   return uid;
2521 }
2522
2523
2524 /* Return true if the user id UID already exists in the keyblock.  */
2525 static int
2526 uid_already_in_keyblock (kbnode_t keyblock, const char *uid)
2527 {
2528   PKT_user_id *uidpkt = uid_from_string (uid);
2529   kbnode_t node;
2530   int result = 0;
2531
2532   for (node=keyblock; node && !result; node=node->next)
2533     if (!is_deleted_kbnode (node)
2534         && node->pkt->pkttype == PKT_USER_ID
2535         && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2536       result = 1;
2537   free_user_id (uidpkt);
2538   return result;
2539 }
2540
2541
2542 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2543    printed for use during a new key creation.  If KEYBLOCK is not NULL
2544    the function prevents the creation of an already existing user
2545    ID.  IF FULL is not set some prompts are not shown.  */
2546 static char *
2547 ask_user_id (int mode, int full, KBNODE keyblock)
2548 {
2549     char *answer;
2550     char *aname, *acomment, *amail, *uid;
2551
2552     if ( !mode )
2553       {
2554         /* TRANSLATORS: This is the new string telling the user what
2555            gpg is now going to do (i.e. ask for the parts of the user
2556            ID).  Note that if you do not translate this string, a
2557            different string will be used, which might still have
2558            a correct translation.  */
2559         const char *s1 =
2560           N_("\n"
2561              "GnuPG needs to construct a user ID to identify your key.\n"
2562              "\n");
2563         const char *s2 = _(s1);
2564
2565         if (!strcmp (s1, s2))
2566           {
2567             /* There is no translation for the string thus we to use
2568                the old info text.  gettext has no way to tell whether
2569                a translation is actually available, thus we need to
2570                to compare again. */
2571             /* TRANSLATORS: This string is in general not anymore used
2572                but you should keep your existing translation.  In case
2573                the new string is not translated this old string will
2574                be used. */
2575             const char *s3 = N_("\n"
2576 "You need a user ID to identify your key; "
2577                                         "the software constructs the user ID\n"
2578 "from the Real Name, Comment and Email Address in this form:\n"
2579 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2580             const char *s4 = _(s3);
2581             if (strcmp (s3, s4))
2582               s2 = s3; /* A translation exists - use it. */
2583           }
2584         tty_printf ("%s", s2) ;
2585       }
2586     uid = aname = acomment = amail = NULL;
2587     for(;;) {
2588         char *p;
2589         int fail=0;
2590
2591         if( !aname ) {
2592             for(;;) {
2593                 xfree(aname);
2594                 aname = cpr_get("keygen.name",_("Real name: "));
2595                 trim_spaces(aname);
2596                 cpr_kill_prompt();
2597
2598                 if( opt.allow_freeform_uid )
2599                     break;
2600
2601                 if( strpbrk( aname, "<>" ) )
2602                   {
2603                     tty_printf(_("Invalid character in name\n"));
2604                     tty_printf(_("The characters '%s' and '%s' may not "
2605                                  "appear in name\n"), "<", ">");
2606                   }
2607                 else if( digitp(aname) )
2608                     tty_printf(_("Name may not start with a digit\n"));
2609                 else if (*aname && strlen (aname) < 5)
2610                   {
2611                     tty_printf(_("Name must be at least 5 characters long\n"));
2612                     /* However, we allow an empty name.  */
2613                   }
2614                 else
2615                     break;
2616             }
2617         }
2618         if( !amail ) {
2619             for(;;) {
2620                 xfree(amail);
2621                 amail = cpr_get("keygen.email",_("Email address: "));
2622                 trim_spaces(amail);
2623                 cpr_kill_prompt();
2624                 if( !*amail || opt.allow_freeform_uid )
2625                     break;   /* no email address is okay */
2626                 else if ( !is_valid_mailbox (amail) )
2627                     tty_printf(_("Not a valid email address\n"));
2628                 else
2629                     break;
2630             }
2631         }
2632         if (!acomment) {
2633           if (full) {
2634             for(;;) {
2635                 xfree(acomment);
2636                 acomment = cpr_get("keygen.comment",_("Comment: "));
2637                 trim_spaces(acomment);
2638                 cpr_kill_prompt();
2639                 if( !*acomment )
2640                     break;   /* no comment is okay */
2641                 else if( strpbrk( acomment, "()" ) )
2642                     tty_printf(_("Invalid character in comment\n"));
2643                 else
2644                     break;
2645             }
2646           }
2647           else {
2648             xfree (acomment);
2649             acomment = xstrdup ("");
2650           }
2651         }
2652
2653
2654         xfree(uid);
2655         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2656         if (!*aname && *amail && !*acomment && !random_is_faked ())
2657           { /* Empty name and comment but with mail address.  Use
2658                simplified form with only the non-angle-bracketed mail
2659                address.  */
2660             p = stpcpy (p, amail);
2661           }
2662         else
2663           {
2664             p = stpcpy (p, aname );
2665             if (*acomment)
2666               p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2667             if (*amail)
2668               p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2669           }
2670
2671         /* Append a warning if the RNG is switched into fake mode.  */
2672         if ( random_is_faked ()  )
2673           strcpy(p, " (insecure!)" );
2674
2675         /* print a note in case that UTF8 mapping has to be done */
2676         for(p=uid; *p; p++ ) {
2677             if( *p & 0x80 ) {
2678                 tty_printf(_("You are using the '%s' character set.\n"),
2679                            get_native_charset() );
2680                 break;
2681             }
2682         }
2683
2684         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2685
2686         if( !*amail && !opt.allow_freeform_uid
2687             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2688             fail = 1;
2689             tty_printf(_("Please don't put the email address "
2690                          "into the real name or the comment\n") );
2691         }
2692
2693         if (!fail && keyblock)
2694           {
2695             if (uid_already_in_keyblock (keyblock, uid))
2696               {
2697                 tty_printf (_("Such a user ID already exists on this key!\n"));
2698                 fail = 1;
2699               }
2700           }
2701
2702         for(;;) {
2703             /* TRANSLATORS: These are the allowed answers in
2704                lower and uppercase.  Below you will find the matching
2705                string which should be translated accordingly and the
2706                letter changed to match the one in the answer string.
2707
2708                  n = Change name
2709                  c = Change comment
2710                  e = Change email
2711                  o = Okay (ready, continue)
2712                  q = Quit
2713              */
2714             const char *ansstr = _("NnCcEeOoQq");
2715
2716             if( strlen(ansstr) != 10 )
2717                 BUG();
2718             if( cpr_enabled() ) {
2719                 answer = xstrdup (ansstr + (fail?8:6));
2720                 answer[1] = 0;
2721             }
2722             else if (full) {
2723                 answer = cpr_get("keygen.userid.cmd", fail?
2724                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2725                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2726                 cpr_kill_prompt();
2727             }
2728             else {
2729                 answer = cpr_get("keygen.userid.cmd", fail?
2730                   _("Change (N)ame, (E)mail, or (Q)uit? ") :
2731                   _("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
2732                 cpr_kill_prompt();
2733             }
2734             if( strlen(answer) > 1 )
2735                 ;
2736             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2737                 xfree(aname); aname = NULL;
2738                 break;
2739             }
2740             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2741                 xfree(acomment); acomment = NULL;
2742                 break;
2743             }
2744             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2745                 xfree(amail); amail = NULL;
2746                 break;
2747             }
2748             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2749                 if( fail ) {
2750                     tty_printf(_("Please correct the error first\n"));
2751                 }
2752                 else {
2753                     xfree(aname); aname = NULL;
2754                     xfree(acomment); acomment = NULL;
2755                     xfree(amail); amail = NULL;
2756                     break;
2757                 }
2758             }
2759             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2760                 xfree(aname); aname = NULL;
2761                 xfree(acomment); acomment = NULL;
2762                 xfree(amail); amail = NULL;
2763                 xfree(uid); uid = NULL;
2764                 break;
2765             }
2766             xfree(answer);
2767         }
2768         xfree(answer);
2769         if (!amail && !acomment)
2770             break;
2771         xfree(uid); uid = NULL;
2772     }
2773     if( uid ) {
2774         char *p = native_to_utf8( uid );
2775         xfree( uid );
2776         uid = p;
2777     }
2778     return uid;
2779 }
2780
2781
2782 /* Basic key generation.  Here we divert to the actual generation
2783    routines based on the requested algorithm.  */
2784 static int
2785 do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
2786            u32 timestamp, u32 expiredate, int is_subkey,
2787            int keygen_flags, const char *passphrase,
2788            char **cache_nonce_addr, char **passwd_nonce_addr)
2789 {
2790   gpg_error_t err;
2791
2792   /* Fixme: The entropy collecting message should be moved to a
2793      libgcrypt progress handler.  */
2794   if (!opt.batch)
2795     tty_printf (_(
2796 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2797 "some other action (type on the keyboard, move the mouse, utilize the\n"
2798 "disks) during the prime generation; this gives the random number\n"
2799 "generator a better chance to gain enough entropy.\n") );
2800
2801   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2802     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2803                    keygen_flags, passphrase,
2804                    cache_nonce_addr, passwd_nonce_addr);
2805   else if (algo == PUBKEY_ALGO_DSA)
2806     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2807                    keygen_flags, passphrase,
2808                    cache_nonce_addr, passwd_nonce_addr);
2809   else if (algo == PUBKEY_ALGO_ECDSA
2810            || algo == PUBKEY_ALGO_EDDSA
2811            || algo == PUBKEY_ALGO_ECDH)
2812     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
2813                    keygen_flags, passphrase,
2814                    cache_nonce_addr, passwd_nonce_addr);
2815   else if (algo == PUBKEY_ALGO_RSA)
2816     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2817                    keygen_flags, passphrase,
2818                    cache_nonce_addr, passwd_nonce_addr);
2819   else
2820     BUG();
2821
2822   return err;
2823 }
2824
2825
2826 /* Generate a new user id packet or return NULL if canceled.  If
2827    KEYBLOCK is not NULL the function prevents the creation of an
2828    already existing user ID.  If UIDSTR is not NULL the user is not
2829    asked but UIDSTR is used to create the user id packet; if the user
2830    id already exists NULL is returned.  UIDSTR is expected to be utf-8
2831    encoded and should have already been checked for a valid length
2832    etc.  */
2833 PKT_user_id *
2834 generate_user_id (KBNODE keyblock, const char *uidstr)
2835 {
2836   PKT_user_id *uid;
2837   char *p;
2838
2839   if (uidstr)
2840     {
2841       if (uid_already_in_keyblock (keyblock, uidstr))
2842         return NULL;  /* Already exists.  */
2843       uid = uid_from_string (uidstr);
2844     }
2845   else
2846     {
2847       p = ask_user_id (1, 1, keyblock);
2848       if (!p)
2849         return NULL;  /* Canceled. */
2850       uid = uid_from_string (p);
2851       xfree (p);
2852     }
2853   return uid;
2854 }
2855
2856
2857 /* Append R to the linked list PARA.  */
2858 static void
2859 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
2860 {
2861   log_assert (para);
2862   while (para->next)
2863     para = para->next;
2864   para->next = r;
2865 }
2866
2867 /* Release the parameter list R.  */
2868 static void
2869 release_parameter_list (struct para_data_s *r)
2870 {
2871   struct para_data_s *r2;
2872
2873   for (; r ; r = r2)
2874     {
2875       r2 = r->next;
2876       if (r->key == pPASSPHRASE && *r->u.value)
2877         wipememory (r->u.value, strlen (r->u.value));
2878       xfree (r);
2879     }
2880 }
2881
2882 static struct para_data_s *
2883 get_parameter( struct para_data_s *para, enum para_name key )
2884 {
2885     struct para_data_s *r;
2886
2887     for( r = para; r && r->key != key; r = r->next )
2888         ;
2889     return r;
2890 }
2891
2892 static const char *
2893 get_parameter_value( struct para_data_s *para, enum para_name key )
2894 {
2895     struct para_data_s *r = get_parameter( para, key );
2896     return (r && *r->u.value)? r->u.value : NULL;
2897 }
2898
2899
2900 /* This is similar to get_parameter_value but also returns the empty
2901    string.  This is required so that quick_generate_keypair can use an
2902    empty Passphrase to specify no-protection.  */
2903 static const char *
2904 get_parameter_passphrase (struct para_data_s *para)
2905 {
2906   struct para_data_s *r = get_parameter (para, pPASSPHRASE);
2907   return r ? r->u.value : NULL;
2908 }
2909
2910
2911 static int
2912 get_parameter_algo( struct para_data_s *para, enum para_name key,
2913                     int *r_default)
2914 {
2915   int i;
2916   struct para_data_s *r = get_parameter( para, key );
2917
2918   if (r_default)
2919     *r_default = 0;
2920
2921   if (!r)
2922     return -1;
2923
2924   /* Note that we need to handle the ECC algorithms specified as
2925      strings directly because Libgcrypt folds them all to ECC.  */
2926   if (!ascii_strcasecmp (r->u.value, "default"))
2927     {
2928       /* Note: If you change this default algo, remember to change it
2929          also in gpg.c:gpgconf_list.  */
2930       i = DEFAULT_STD_ALGO;
2931       if (r_default)
2932         *r_default = 1;
2933     }
2934   else if (digitp (r->u.value))
2935     i = atoi( r->u.value );
2936   else if (!strcmp (r->u.value, "ELG-E")
2937            || !strcmp (r->u.value, "ELG"))
2938     i = PUBKEY_ALGO_ELGAMAL_E;
2939   else if (!ascii_strcasecmp (r->u.value, "EdDSA"))
2940     i = PUBKEY_ALGO_EDDSA;
2941   else if (!ascii_strcasecmp (r->u.value, "ECDSA"))
2942     i = PUBKEY_ALGO_ECDSA;
2943   else if (!ascii_strcasecmp (r->u.value, "ECDH"))
2944     i = PUBKEY_ALGO_ECDH;
2945   else
2946     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
2947
2948   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2949     i = 0; /* we don't want to allow generation of these algorithms */
2950   return i;
2951 }
2952
2953
2954 /* Parse a usage string.  The usage keywords "auth", "sign", "encr"
2955  * may be elimited by space, tab, or comma.  On error -1 is returned
2956  * instead of the usage flags/  */
2957 static int
2958 parse_usagestr (const char *usagestr)
2959 {
2960   gpg_error_t err;
2961   char **tokens = NULL;
2962   const char *s;
2963   int i;
2964   unsigned int use = 0;
2965
2966   tokens = strtokenize (usagestr, " \t,");
2967   if (!tokens)
2968     {
2969       err = gpg_error_from_syserror ();
2970       log_error ("strtokenize failed: %s\n", gpg_strerror (err));
2971       return -1;
2972     }
2973
2974   for (i=0; (s = tokens[i]); i++)
2975     {
2976       if (!*s)
2977         ;
2978       else if (!ascii_strcasecmp (s, "sign"))
2979         use |= PUBKEY_USAGE_SIG;
2980       else if (!ascii_strcasecmp (s, "encrypt")
2981                 || !ascii_strcasecmp (s, "encr"))
2982         use |= PUBKEY_USAGE_ENC;
2983       else if (!ascii_strcasecmp (s, "auth"))
2984         use |= PUBKEY_USAGE_AUTH;
2985       else if (!ascii_strcasecmp (s, "cert"))
2986         use |= PUBKEY_USAGE_CERT;
2987       else
2988         {
2989           xfree (tokens);
2990           return -1; /* error */
2991         }
2992     }
2993
2994   xfree (tokens);
2995   return use;
2996 }
2997
2998
2999 /*
3000  * Parse the usage parameter and set the keyflags.  Returns -1 on
3001  * error, 0 for no usage given or 1 for usage available.
3002  */
3003 static int
3004 parse_parameter_usage (const char *fname,
3005                        struct para_data_s *para, enum para_name key)
3006 {
3007   struct para_data_s *r = get_parameter( para, key );
3008   int i;
3009
3010   if (!r)
3011     return 0; /* none (this is an optional parameter)*/
3012
3013   i = parse_usagestr (r->u.value);
3014   if (i == -1)
3015     {
3016       log_error ("%s:%d: invalid usage list\n", fname, r->lnr );
3017       return -1; /* error */
3018     }
3019
3020   r->u.usage = i;
3021   return 1;
3022 }
3023
3024
3025 static int
3026 parse_revocation_key (const char *fname,
3027                       struct para_data_s *para, enum para_name key)
3028 {
3029   struct para_data_s *r = get_parameter( para, key );
3030   struct revocation_key revkey;
3031   char *pn;
3032   int i;
3033
3034   if( !r )
3035     return 0; /* none (this is an optional parameter) */
3036
3037   pn = r->u.value;
3038
3039   revkey.class=0x80;
3040   revkey.algid=atoi(pn);
3041   if(!revkey.algid)
3042     goto fail;
3043
3044   /* Skip to the fpr */
3045   while(*pn && *pn!=':')
3046     pn++;
3047
3048   if(*pn!=':')
3049     goto fail;
3050
3051   pn++;
3052
3053   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
3054     {
3055       int c=hextobyte(pn);
3056       if(c==-1)
3057         goto fail;
3058
3059       revkey.fpr[i]=c;
3060     }
3061
3062   /* skip to the tag */
3063   while(*pn && *pn!='s' && *pn!='S')
3064     pn++;
3065
3066   if(ascii_strcasecmp(pn,"sensitive")==0)
3067     revkey.class|=0x40;
3068
3069   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
3070
3071   return 0;
3072
3073   fail:
3074   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
3075   return -1; /* error */
3076 }
3077
3078
3079 static u32
3080 get_parameter_u32( struct para_data_s *para, enum para_name key )
3081 {
3082   struct para_data_s *r = get_parameter( para, key );
3083
3084   if( !r )
3085     return 0;
3086   if( r->key == pKEYCREATIONDATE )
3087     return r->u.creation;
3088   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
3089     return r->u.expire;
3090   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
3091     return r->u.usage;
3092
3093   return (unsigned int)strtoul( r->u.value, NULL, 10 );
3094 }
3095
3096 static unsigned int
3097 get_parameter_uint( struct para_data_s *para, enum para_name key )
3098 {
3099     return get_parameter_u32( para, key );
3100 }
3101
3102 static struct revocation_key *
3103 get_parameter_revkey( struct para_data_s *para, enum para_name key )
3104 {
3105     struct para_data_s *r = get_parameter( para, key );
3106     return r? &r->u.revkey : NULL;
3107 }
3108
3109 static int
3110 proc_parameter_file (ctrl_t ctrl, struct para_data_s *para, const char *fname,
3111                      struct output_control_s *outctrl, int card )
3112 {
3113   struct para_data_s *r;
3114   const char *s1, *s2, *s3;
3115   size_t n;
3116   char *p;
3117   int is_default = 0;
3118   int have_user_id = 0;
3119   int err, algo;
3120
3121   /* Check that we have all required parameters. */
3122   r = get_parameter( para, pKEYTYPE );
3123   if(r)
3124     {
3125       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
3126       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
3127         {
3128           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3129           return -1;
3130         }
3131     }
3132   else
3133     {
3134       log_error ("%s: no Key-Type specified\n",fname);
3135       return -1;
3136     }
3137
3138   err = parse_parameter_usage (fname, para, pKEYUSAGE);
3139   if (!err)
3140     {
3141       /* Default to algo capabilities if key-usage is not provided and
3142          no default algorithm has been requested.  */
3143       r = xmalloc_clear(sizeof(*r));
3144       r->key = pKEYUSAGE;
3145       r->u.usage = (is_default
3146                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
3147                     : openpgp_pk_algo_usage(algo));
3148       append_to_parameter (para, r);
3149     }
3150   else if (err == -1)
3151     return -1;
3152   else
3153     {
3154       r = get_parameter (para, pKEYUSAGE);
3155       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3156         {
3157           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
3158                      fname, r->lnr, algo);
3159           return -1;
3160         }
3161     }
3162
3163   is_default = 0;
3164   r = get_parameter( para, pSUBKEYTYPE );
3165   if(r)
3166     {
3167       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
3168       if (openpgp_pk_test_algo (algo))
3169         {
3170           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3171           return -1;
3172         }
3173
3174       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
3175       if (!err)
3176         {
3177           /* Default to algo capabilities if subkey-usage is not
3178              provided */
3179           r = xmalloc_clear (sizeof(*r));
3180           r->key = pSUBKEYUSAGE;
3181           r->u.usage = (is_default
3182                         ? PUBKEY_USAGE_ENC
3183                         : openpgp_pk_algo_usage (algo));
3184           append_to_parameter (para, r);
3185         }
3186       else if (err == -1)
3187         return -1;
3188       else
3189         {
3190           r = get_parameter (para, pSUBKEYUSAGE);
3191           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3192             {
3193               log_error ("%s:%d: specified Subkey-Usage not allowed"
3194                          " for algo %d\n", fname, r->lnr, algo);
3195               return -1;
3196             }
3197         }
3198     }
3199
3200
3201   if( get_parameter_value( para, pUSERID ) )
3202     have_user_id=1;
3203   else
3204     {
3205       /* create the formatted user ID */
3206       s1 = get_parameter_value( para, pNAMEREAL );
3207       s2 = get_parameter_value( para, pNAMECOMMENT );
3208       s3 = get_parameter_value( para, pNAMEEMAIL );
3209       if( s1 || s2 || s3 )
3210         {
3211           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
3212           r = xmalloc_clear( sizeof *r + n + 20 );
3213           r->key = pUSERID;
3214           p = r->u.value;
3215           if( s1 )
3216             p = stpcpy(p, s1 );
3217           if( s2 )
3218             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
3219           if( s3 )
3220             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
3221           append_to_parameter (para, r);
3222           have_user_id=1;
3223         }
3224     }
3225
3226   if(!have_user_id)
3227     {
3228       log_error("%s: no User-ID specified\n",fname);
3229       return -1;
3230     }
3231
3232   /* Set preferences, if any. */
3233   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
3234
3235   /* Set keyserver, if any. */
3236   s1=get_parameter_value( para, pKEYSERVER );
3237   if(s1)
3238     {
3239       struct keyserver_spec *spec;
3240
3241       spec = parse_keyserver_uri (s1, 1);
3242       if(spec)
3243         {
3244           free_keyserver_spec(spec);
3245           opt.def_keyserver_url=s1;
3246         }
3247       else
3248         {
3249           r = get_parameter (para, pKEYSERVER);
3250           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
3251           return -1;
3252         }
3253     }
3254
3255   /* Set revoker, if any. */
3256   if (parse_revocation_key (fname, para, pREVOKER))
3257     return -1;
3258
3259
3260   /* Make KEYCREATIONDATE from Creation-Date.  */
3261   r = get_parameter (para, pCREATIONDATE);
3262   if (r && *r->u.value)
3263     {
3264       u32 seconds;
3265
3266       seconds = parse_creation_string (r->u.value);
3267       if (!seconds)
3268         {
3269           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
3270           return -1;
3271         }
3272       r->u.creation = seconds;
3273       r->key = pKEYCREATIONDATE;  /* Change that entry. */
3274     }
3275
3276   /* Make KEYEXPIRE from Expire-Date.  */
3277   r = get_parameter( para, pEXPIREDATE );
3278   if( r && *r->u.value )
3279     {
3280       u32 seconds;
3281
3282       seconds = parse_expire_string( r->u.value );
3283       if( seconds == (u32)-1 )
3284         {
3285           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
3286           return -1;
3287         }
3288       r->u.expire = seconds;
3289       r->key = pKEYEXPIRE;  /* change hat entry */
3290       /* also set it for the subkey */
3291       r = xmalloc_clear( sizeof *r + 20 );
3292       r->key = pSUBKEYEXPIRE;
3293       r->u.expire = seconds;
3294       append_to_parameter (para, r);
3295     }
3296
3297   do_generate_keypair (ctrl, para, outctrl, card );
3298   return 0;
3299 }
3300
3301
3302 /****************
3303  * Kludge to allow non interactive key generation controlled
3304  * by a parameter file.
3305  * Note, that string parameters are expected to be in UTF-8
3306  */
3307 static void
3308 read_parameter_file (ctrl_t ctrl, const char *fname )
3309 {
3310     static struct { const char *name;
3311                     enum para_name key;
3312     } keywords[] = {
3313         { "Key-Type",       pKEYTYPE},
3314         { "Key-Length",     pKEYLENGTH },
3315         { "Key-Curve",      pKEYCURVE },
3316         { "Key-Usage",      pKEYUSAGE },
3317         { "Subkey-Type",    pSUBKEYTYPE },
3318         { "Subkey-Length",  pSUBKEYLENGTH },
3319         { "Subkey-Curve",   pSUBKEYCURVE },
3320         { "Subkey-Usage",   pSUBKEYUSAGE },
3321         { "Name-Real",      pNAMEREAL },
3322         { "Name-Email",     pNAMEEMAIL },
3323         { "Name-Comment",   pNAMECOMMENT },
3324         { "Expire-Date",    pEXPIREDATE },
3325         { "Creation-Date",  pCREATIONDATE },
3326         { "Passphrase",     pPASSPHRASE },
3327         { "Preferences",    pPREFERENCES },
3328         { "Revoker",        pREVOKER },
3329         { "Handle",         pHANDLE },
3330         { "Keyserver",      pKEYSERVER },
3331         { NULL, 0 }
3332     };
3333     IOBUF fp;
3334     byte *line;
3335     unsigned int maxlen, nline;
3336     char *p;
3337     int lnr;
3338     const char *err = NULL;
3339     struct para_data_s *para, *r;
3340     int i;
3341     struct output_control_s outctrl;
3342
3343     memset( &outctrl, 0, sizeof( outctrl ) );
3344     outctrl.pub.afx = new_armor_context ();
3345
3346     if( !fname || !*fname)
3347       fname = "-";
3348
3349     fp = iobuf_open (fname);
3350     if (fp && is_secured_file (iobuf_get_fd (fp)))
3351       {
3352         iobuf_close (fp);
3353         fp = NULL;
3354         gpg_err_set_errno (EPERM);
3355       }
3356     if (!fp) {
3357       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
3358       return;
3359     }
3360     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
3361
3362     lnr = 0;
3363     err = NULL;
3364     para = NULL;
3365     maxlen = 1024;
3366     line = NULL;
3367     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
3368         char *keyword, *value;
3369
3370         lnr++;
3371         if( !maxlen ) {
3372             err = "line too long";
3373             break;
3374         }
3375         for( p = line; isspace(*(byte*)p); p++ )
3376             ;
3377         if( !*p || *p == '#' )
3378             continue;
3379         keyword = p;
3380         if( *keyword == '%' ) {
3381             for( ; !isspace(*(byte*)p); p++ )
3382                 ;
3383             if( *p )
3384                 *p++ = 0;
3385             for( ; isspace(*(byte*)p); p++ )
3386                 ;
3387             value = p;
3388             trim_trailing_ws( value, strlen(value) );
3389             if( !ascii_strcasecmp( keyword, "%echo" ) )
3390                 log_info("%s\n", value );
3391             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
3392                 outctrl.dryrun = 1;
3393             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
3394               ; /* Dummy for backward compatibility. */
3395             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
3396               ; /* Dummy for backward compatibility. */
3397             else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
3398                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
3399             else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
3400                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
3401             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
3402                 outctrl.lnr = lnr;
3403                 if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3404                   print_status_key_not_created
3405                     (get_parameter_value (para, pHANDLE));
3406                 release_parameter_list( para );
3407                 para = NULL;
3408             }
3409             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
3410                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
3411                     ; /* still the same file - ignore it */
3412                 else {
3413                     xfree( outctrl.pub.newfname );
3414                     outctrl.pub.newfname = xstrdup( value );
3415                     outctrl.use_files = 1;
3416                 }
3417             }
3418             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
3419               /* Ignore this command.  */
3420             }
3421             else
3422                 log_info("skipping control '%s' (%s)\n", keyword, value );
3423
3424
3425             continue;
3426         }
3427
3428
3429         if( !(p = strchr( p, ':' )) || p == keyword ) {
3430             err = "missing colon";
3431             break;
3432         }
3433         if( *p )
3434             *p++ = 0;
3435         for( ; isspace(*(byte*)p); p++ )
3436             ;
3437         if( !*p ) {
3438             err = "missing argument";
3439             break;
3440         }
3441         value = p;
3442         trim_trailing_ws( value, strlen(value) );
3443
3444         for(i=0; keywords[i].name; i++ ) {
3445             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
3446                 break;
3447         }
3448         if( !keywords[i].name ) {
3449             err = "unknown keyword";
3450             break;
3451         }
3452         if( keywords[i].key != pKEYTYPE && !para ) {
3453             err = "parameter block does not start with \"Key-Type\"";
3454             break;
3455         }
3456
3457         if( keywords[i].key == pKEYTYPE && para ) {
3458             outctrl.lnr = lnr;
3459             if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3460               print_status_key_not_created
3461                 (get_parameter_value (para, pHANDLE));
3462             release_parameter_list( para );
3463             para = NULL;
3464         }
3465         else {
3466             for( r = para; r; r = r->next ) {
3467                 if( r->key == keywords[i].key )
3468                     break;
3469             }
3470             if( r ) {
3471                 err = "duplicate keyword";
3472                 break;
3473             }
3474         }
3475         r = xmalloc_clear( sizeof *r + strlen( value ) );
3476         r->lnr = lnr;
3477         r->key = keywords[i].key;
3478         strcpy( r->u.value, value );
3479         r->next = para;
3480         para = r;
3481     }
3482     if( err )
3483         log_error("%s:%d: %s\n", fname, lnr, err );
3484     else if( iobuf_error (fp) ) {
3485         log_error("%s:%d: read error\n", fname, lnr);
3486     }
3487     else if( para ) {
3488         outctrl.lnr = lnr;
3489         if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3490           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3491     }
3492
3493     if( outctrl.use_files ) { /* close open streams */
3494         iobuf_close( outctrl.pub.stream );
3495
3496         /* Must invalidate that ugly cache to actually close it.  */
3497         if (outctrl.pub.fname)
3498           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3499                        0, (char*)outctrl.pub.fname);
3500
3501         xfree( outctrl.pub.fname );
3502         xfree( outctrl.pub.newfname );
3503     }
3504
3505     xfree (line);
3506     release_parameter_list( para );
3507     iobuf_close (fp);
3508     release_armor_context (outctrl.pub.afx);
3509 }
3510
3511
3512 /* Helper for quick_generate_keypair.  */
3513 static struct para_data_s *
3514 quickgen_set_para (struct para_data_s *para, int for_subkey,
3515                    int algo, int nbits, const char *curve, unsigned int use)
3516 {
3517   struct para_data_s *r;
3518
3519   r = xmalloc_clear (sizeof *r + 30);
3520   r->key = for_subkey? pSUBKEYUSAGE :  pKEYUSAGE;
3521   if (use)
3522     snprintf (r->u.value, 30, "%s%s%s%s",
3523               (use & PUBKEY_USAGE_ENC)?  "encr " : "",
3524               (use & PUBKEY_USAGE_SIG)?  "sign " : "",
3525               (use & PUBKEY_USAGE_AUTH)? "auth " : "",
3526               (use & PUBKEY_USAGE_CERT)? "cert " : "");
3527   else
3528     strcpy (r->u.value, for_subkey ? "encr" : "sign");
3529   r->next = para;
3530   para = r;
3531   r = xmalloc_clear (sizeof *r + 20);
3532   r->key = for_subkey? pSUBKEYTYPE : pKEYTYPE;
3533   snprintf (r->u.value, 20, "%d", algo);
3534   r->next = para;
3535   para = r;
3536
3537   if (curve)
3538     {
3539       r = xmalloc_clear (sizeof *r + strlen (curve));
3540       r->key = for_subkey? pSUBKEYCURVE : pKEYCURVE;
3541       strcpy (r->u.value, curve);
3542       r->next = para;
3543       para = r;
3544     }
3545   else
3546     {
3547       r = xmalloc_clear (sizeof *r + 20);
3548       r->key = for_subkey? pSUBKEYLENGTH : pKEYLENGTH;
3549       sprintf (r->u.value, "%u", nbits);
3550       r->next = para;
3551       para = r;
3552     }
3553
3554   return para;
3555 }
3556
3557
3558 /*
3559  * Unattended generation of a standard key.
3560  */
3561 void
3562 quick_generate_keypair (ctrl_t ctrl, const char *uid, const char *algostr,
3563                         const char *usagestr, const char *expirestr)
3564 {
3565   gpg_error_t err;
3566   struct para_data_s *para = NULL;
3567   struct para_data_s *r;
3568   struct output_control_s outctrl;
3569   int use_tty;
3570
3571   memset (&outctrl, 0, sizeof outctrl);
3572
3573   use_tty = (!opt.batch && !opt.answer_yes
3574              && !*algostr && !*usagestr && !*expirestr
3575              && !cpr_enabled ()
3576              && gnupg_isatty (fileno (stdin))
3577              && gnupg_isatty (fileno (stdout))
3578              && gnupg_isatty (fileno (stderr)));
3579
3580   r = xmalloc_clear (sizeof *r + strlen (uid));
3581   r->key = pUSERID;
3582   strcpy (r->u.value, uid);
3583   r->next = para;
3584   para = r;
3585
3586   uid = trim_spaces (r->u.value);
3587   if (!*uid || (!opt.allow_freeform_uid && !is_valid_user_id (uid)))
3588     {
3589       log_error (_("Key generation failed: %s\n"),
3590                  gpg_strerror (GPG_ERR_INV_USER_ID));
3591       goto leave;
3592     }
3593
3594   /* If gpg is directly used on the console ask whether a key with the
3595      given user id shall really be created.  */
3596   if (use_tty)
3597     {
3598       tty_printf (_("About to create a key for:\n    \"%s\"\n\n"), uid);
3599       if (!cpr_get_answer_is_yes_def ("quick_keygen.okay",
3600                                       _("Continue? (Y/n) "), 1))
3601         goto leave;
3602     }
3603
3604   /* Check whether such a user ID already exists.  */
3605   {
3606     KEYDB_HANDLE kdbhd;
3607     KEYDB_SEARCH_DESC desc;
3608
3609     memset (&desc, 0, sizeof desc);
3610     desc.mode = KEYDB_SEARCH_MODE_EXACT;
3611     desc.u.name = uid;
3612
3613     kdbhd = keydb_new ();
3614     if (!kdbhd)
3615       goto leave;
3616
3617     err = keydb_search (kdbhd, &desc, 1, NULL);
3618     keydb_release (kdbhd);
3619     if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
3620       {
3621         log_info (_("A key for \"%s\" already exists\n"), uid);
3622         if (opt.answer_yes)
3623           ;
3624         else if (!use_tty
3625                  || !cpr_get_answer_is_yes_def ("quick_keygen.force",
3626                                                 _("Create anyway? (y/N) "), 0))
3627           {
3628             write_status_error ("genkey", gpg_error (304));
3629             log_inc_errorcount ();  /* we used log_info */
3630             goto leave;
3631           }
3632         log_info (_("creating anyway\n"));
3633       }
3634   }
3635
3636
3637   if ((!*algostr || !strcmp (algostr, "default")
3638        || !strcmp (algostr, "future-default"))
3639       && (!*usagestr || !strcmp (usagestr, "default")
3640           || !strcmp (usagestr, "-")))
3641     {
3642       if (!strcmp (algostr, "future-default"))
3643         {
3644           para = quickgen_set_para (para, 0,
3645                                     FUTURE_STD_ALGO, FUTURE_STD_KEYSIZE,
3646                                     FUTURE_STD_CURVE, 0);
3647           para = quickgen_set_para (para, 1,
3648                                     FUTURE_STD_SUBALGO,  FUTURE_STD_SUBKEYSIZE,
3649                                     FUTURE_STD_SUBCURVE, 0);
3650         }
3651       else
3652         {