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