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