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