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