gpg: Add shortcut for setting key capabilities.
[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   const char *s;
1659   unsigned int current=0;
1660   unsigned int possible=openpgp_pk_algo_usage(algo);
1661
1662   if ( strlen(togglers) != 8 )
1663     {
1664       tty_printf ("NOTE: Bad translation at %s:%d. "
1665                   "Please report.\n", __FILE__, __LINE__);
1666       togglers = "11223300";
1667     }
1668
1669   /* Only primary keys may certify. */
1670   if(subkey)
1671     possible&=~PUBKEY_USAGE_CERT;
1672
1673   /* Preload the current set with the possible set, minus
1674      authentication, since nobody really uses auth yet. */
1675   current=possible&~PUBKEY_USAGE_AUTH;
1676
1677   for(;;)
1678     {
1679       tty_printf("\n");
1680       tty_printf(_("Possible actions for a %s key: "),
1681                  openpgp_pk_algo_name (algo));
1682       print_key_flags(possible);
1683       tty_printf("\n");
1684       tty_printf(_("Current allowed actions: "));
1685       print_key_flags(current);
1686       tty_printf("\n\n");
1687
1688       if(possible&PUBKEY_USAGE_SIG)
1689         tty_printf(_("   (%c) Toggle the sign capability\n"),
1690                    togglers[0]);
1691       if(possible&PUBKEY_USAGE_ENC)
1692         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1693                    togglers[2]);
1694       if(possible&PUBKEY_USAGE_AUTH)
1695         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1696                    togglers[4]);
1697
1698       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1699       tty_printf("\n");
1700
1701       xfree(answer);
1702       answer = cpr_get("keygen.flags",_("Your selection? "));
1703       cpr_kill_prompt();
1704
1705       if (*answer == '=')
1706         {
1707           /* Hack to allow direct entry of the capabilities.  */
1708           current = 0;
1709           for (s=answer+1; *s; s++)
1710             {
1711               if ((*s == 's' || *s == 'S') && (possible&PUBKEY_USAGE_SIG))
1712                 current |= PUBKEY_USAGE_SIG;
1713               else if ((*s == 'e' || *s == 'E') && (possible&PUBKEY_USAGE_ENC))
1714                 current |= PUBKEY_USAGE_ENC;
1715               else if ((*s == 'a' || *s == 'A') && (possible&PUBKEY_USAGE_AUTH))
1716                 current |= PUBKEY_USAGE_AUTH;
1717             }
1718           break;
1719         }
1720       else if (strlen(answer)>1)
1721         tty_printf(_("Invalid selection.\n"));
1722       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1723         break;
1724       else if((*answer==togglers[0] || *answer==togglers[1])
1725               && possible&PUBKEY_USAGE_SIG)
1726         {
1727           if(current&PUBKEY_USAGE_SIG)
1728             current&=~PUBKEY_USAGE_SIG;
1729           else
1730             current|=PUBKEY_USAGE_SIG;
1731         }
1732       else if((*answer==togglers[2] || *answer==togglers[3])
1733               && possible&PUBKEY_USAGE_ENC)
1734         {
1735           if(current&PUBKEY_USAGE_ENC)
1736             current&=~PUBKEY_USAGE_ENC;
1737           else
1738             current|=PUBKEY_USAGE_ENC;
1739         }
1740       else if((*answer==togglers[4] || *answer==togglers[5])
1741               && possible&PUBKEY_USAGE_AUTH)
1742         {
1743           if(current&PUBKEY_USAGE_AUTH)
1744             current&=~PUBKEY_USAGE_AUTH;
1745           else
1746             current|=PUBKEY_USAGE_AUTH;
1747         }
1748       else
1749         tty_printf(_("Invalid selection.\n"));
1750     }
1751
1752   xfree(answer);
1753
1754   return current;
1755 }
1756
1757
1758 /* Check whether we have a key for the key with HEXGRIP.  Returns 0 if
1759    there is no such key or the OpenPGP algo number for the key.  */
1760 static int
1761 check_keygrip (ctrl_t ctrl, const char *hexgrip)
1762 {
1763   gpg_error_t err;
1764   unsigned char *public;
1765   size_t publiclen;
1766   const char *algostr;
1767
1768   if (hexgrip[0] == '&')
1769     hexgrip++;
1770
1771   err = agent_readkey (ctrl, 0, hexgrip, &public);
1772   if (err)
1773     return 0;
1774   publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);
1775
1776   get_pk_algo_from_canon_sexp (public, publiclen, &algostr);
1777   xfree (public);
1778
1779   /* FIXME: Mapping of ECC algorithms is probably not correct. */
1780   if (!algostr)
1781     return 0;
1782   else if (!strcmp (algostr, "rsa"))
1783     return PUBKEY_ALGO_RSA;
1784   else if (!strcmp (algostr, "dsa"))
1785     return PUBKEY_ALGO_DSA;
1786   else if (!strcmp (algostr, "elg"))
1787     return PUBKEY_ALGO_ELGAMAL_E;
1788   else if (!strcmp (algostr, "ecc"))
1789     return PUBKEY_ALGO_ECDH;
1790   else if (!strcmp (algostr, "ecdsa"))
1791     return PUBKEY_ALGO_ECDSA;
1792   else if (!strcmp (algostr, "eddsa"))
1793     return PUBKEY_ALGO_EDDSA;
1794   else
1795     return 0;
1796 }
1797
1798
1799
1800 /* Ask for an algorithm.  The function returns the algorithm id to
1801  * create. If ADDMODE is false the function won't show an option to
1802  * create the primary and subkey combined and won't set R_USAGE
1803  * either.  If a combined algorithm has been selected, the subkey
1804  * algorithm is stored at R_SUBKEY_ALGO.  If R_KEYGRIP is given, the
1805  * user has the choice to enter the keygrip of an existing key.  That
1806  * keygrip is then stored at this address.  The caller needs to free
1807  * it. */
1808 static int
1809 ask_algo (ctrl_t ctrl, int addmode, int *r_subkey_algo, unsigned int *r_usage,
1810           char **r_keygrip)
1811 {
1812   char *keygrip = NULL;
1813   char *answer;
1814   int algo;
1815   int dummy_algo;
1816
1817   if (!r_subkey_algo)
1818     r_subkey_algo = &dummy_algo;
1819
1820   tty_printf (_("Please select what kind of key you want:\n"));
1821
1822 #if GPG_USE_RSA
1823   if (!addmode)
1824     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1825 #endif
1826
1827   if (!addmode)
1828     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1829
1830   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1831 #if GPG_USE_RSA
1832   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1833 #endif
1834
1835   if (addmode)
1836     {
1837       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1838 #if GPG_USE_RSA
1839       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1840 #endif
1841     }
1842   if (opt.expert)
1843     {
1844       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1845 #if GPG_USE_RSA
1846       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1847 #endif
1848     }
1849
1850 #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
1851   if (opt.expert && !addmode)
1852     tty_printf (_("   (%d) ECC and ECC\n"), 9 );
1853   if (opt.expert)
1854     tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
1855   if (opt.expert)
1856     tty_printf (_("  (%d) ECC (set your own capabilities)\n"), 11 );
1857   if (opt.expert && addmode)
1858     tty_printf (_("  (%d) ECC (encrypt only)\n"), 12 );
1859 #endif
1860
1861   if (opt.expert && r_keygrip)
1862     tty_printf (_("  (%d) Existing key\n"), 13 );
1863
1864   for (;;)
1865     {
1866       *r_usage = 0;
1867       *r_subkey_algo = 0;
1868       answer = cpr_get ("keygen.algo", _("Your selection? "));
1869       cpr_kill_prompt ();
1870       algo = *answer? atoi (answer) : 1;
1871       xfree(answer);
1872       answer = NULL;
1873       if (algo == 1 && !addmode)
1874         {
1875           algo = PUBKEY_ALGO_RSA;
1876           *r_subkey_algo = PUBKEY_ALGO_RSA;
1877           break;
1878         }
1879       else if (algo == 2 && !addmode)
1880         {
1881           algo = PUBKEY_ALGO_DSA;
1882           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1883           break;
1884         }
1885       else if (algo == 3)
1886         {
1887           algo = PUBKEY_ALGO_DSA;
1888           *r_usage = PUBKEY_USAGE_SIG;
1889           break;
1890         }
1891       else if (algo == 4)
1892         {
1893           algo = PUBKEY_ALGO_RSA;
1894           *r_usage = PUBKEY_USAGE_SIG;
1895           break;
1896         }
1897       else if (algo == 5 && addmode)
1898         {
1899           algo = PUBKEY_ALGO_ELGAMAL_E;
1900           *r_usage = PUBKEY_USAGE_ENC;
1901           break;
1902         }
1903       else if (algo == 6 && addmode)
1904         {
1905           algo = PUBKEY_ALGO_RSA;
1906           *r_usage = PUBKEY_USAGE_ENC;
1907           break;
1908         }
1909       else if (algo == 7 && opt.expert)
1910         {
1911           algo = PUBKEY_ALGO_DSA;
1912           *r_usage = ask_key_flags (algo, addmode);
1913           break;
1914         }
1915       else if (algo == 8 && opt.expert)
1916         {
1917           algo = PUBKEY_ALGO_RSA;
1918           *r_usage = ask_key_flags (algo, addmode);
1919           break;
1920         }
1921       else if (algo == 9 && opt.expert && !addmode)
1922         {
1923           algo = PUBKEY_ALGO_ECDSA;
1924           *r_subkey_algo = PUBKEY_ALGO_ECDH;
1925           break;
1926         }
1927       else if (algo == 10 && opt.expert)
1928         {
1929           algo = PUBKEY_ALGO_ECDSA;
1930           *r_usage = PUBKEY_USAGE_SIG;
1931           break;
1932         }
1933       else if (algo == 11 && opt.expert)
1934         {
1935           algo = PUBKEY_ALGO_ECDSA;
1936           *r_usage = ask_key_flags (algo, addmode);
1937           break;
1938         }
1939       else if (algo == 12 && opt.expert && addmode)
1940         {
1941           algo = PUBKEY_ALGO_ECDH;
1942           *r_usage = PUBKEY_USAGE_ENC;
1943           break;
1944         }
1945       else if (algo == 13 && opt.expert && r_keygrip)
1946         {
1947           for (;;)
1948             {
1949               xfree (answer);
1950               answer = tty_get (_("Enter the keygrip: "));
1951               tty_kill_prompt ();
1952               trim_spaces (answer);
1953               if (!*answer)
1954                 {
1955                   xfree (answer);
1956                   answer = NULL;
1957                   continue;
1958                 }
1959
1960               if (strlen (answer) != 40 &&
1961                        !(answer[0] == '&' && strlen (answer+1) == 40))
1962                 tty_printf
1963                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
1964               else if (!(algo = check_keygrip (ctrl, answer)) )
1965                 tty_printf (_("No key with this keygrip\n"));
1966               else
1967                 break; /* Okay.  */
1968             }
1969           xfree (keygrip);
1970           keygrip = answer;
1971           answer = NULL;
1972           *r_usage = ask_key_flags (algo, addmode);
1973           break;
1974         }
1975       else
1976         tty_printf (_("Invalid selection.\n"));
1977     }
1978
1979   if (r_keygrip)
1980     *r_keygrip = keygrip;
1981   return algo;
1982 }
1983
1984
1985 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1986    is not 0, the function asks for the size of the encryption
1987    subkey. */
1988 static unsigned
1989 ask_keysize (int algo, unsigned int primary_keysize)
1990 {
1991   unsigned int nbits, min, def = DEFAULT_STD_KEYSIZE, max=4096;
1992   int for_subkey = !!primary_keysize;
1993   int autocomp = 0;
1994
1995   if(opt.expert)
1996     min=512;
1997   else
1998     min=1024;
1999
2000   if (primary_keysize && !opt.expert)
2001     {
2002       /* Deduce the subkey size from the primary key size.  */
2003       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
2004         nbits = 3072; /* For performance reasons we don't support more
2005                          than 3072 bit DSA.  However we won't see this
2006                          case anyway because DSA can't be used as an
2007                          encryption subkey ;-). */
2008       else
2009         nbits = primary_keysize;
2010       autocomp = 1;
2011       goto leave;
2012     }
2013
2014   switch(algo)
2015     {
2016     case PUBKEY_ALGO_DSA:
2017       def=2048;
2018       max=3072;
2019       break;
2020
2021     case PUBKEY_ALGO_ECDSA:
2022     case PUBKEY_ALGO_ECDH:
2023       min=256;
2024       def=256;
2025       max=521;
2026       break;
2027
2028     case PUBKEY_ALGO_EDDSA:
2029       min=255;
2030       def=255;
2031       max=441;
2032       break;
2033
2034     case PUBKEY_ALGO_RSA:
2035       min=1024;
2036       break;
2037     }
2038
2039   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
2040              openpgp_pk_algo_name (algo), min, max);
2041
2042   for (;;)
2043     {
2044       char *prompt, *answer;
2045
2046       if (for_subkey)
2047         prompt = xasprintf (_("What keysize do you want "
2048                               "for the subkey? (%u) "), def);
2049       else
2050         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
2051       answer = cpr_get ("keygen.size", prompt);
2052       cpr_kill_prompt ();
2053       nbits = *answer? atoi (answer): def;
2054       xfree(prompt);
2055       xfree(answer);
2056
2057       if(nbits<min || nbits>max)
2058         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
2059                    openpgp_pk_algo_name (algo), min, max);
2060       else
2061         break;
2062     }
2063
2064   tty_printf (_("Requested keysize is %u bits\n"), nbits);
2065
2066  leave:
2067   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
2068     {
2069       nbits = ((nbits + 63) / 64) * 64;
2070       if (!autocomp)
2071         tty_printf (_("rounded up to %u bits\n"), nbits);
2072     }
2073   else if (algo == PUBKEY_ALGO_EDDSA)
2074     {
2075       if (nbits != 255 && nbits != 441)
2076         {
2077           if (nbits < 256)
2078             nbits = 255;
2079           else
2080             nbits = 441;
2081           if (!autocomp)
2082             tty_printf (_("rounded to %u bits\n"), nbits);
2083         }
2084     }
2085   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2086     {
2087       if (nbits != 256 && nbits != 384 && nbits != 521)
2088         {
2089           if (nbits < 256)
2090             nbits = 256;
2091           else if (nbits < 384)
2092             nbits = 384;
2093           else
2094             nbits = 521;
2095           if (!autocomp)
2096             tty_printf (_("rounded to %u bits\n"), nbits);
2097         }
2098     }
2099   else if ((nbits % 32))
2100     {
2101       nbits = ((nbits + 31) / 32) * 32;
2102       if (!autocomp)
2103         tty_printf (_("rounded up to %u bits\n"), nbits );
2104     }
2105
2106   return nbits;
2107 }
2108
2109
2110 /* Ask for the curve.  ALGO is the selected algorithm which this
2111    function may adjust.  Returns a malloced string with the name of
2112    the curve.  BOTH tells that gpg creates a primary and subkey. */
2113 static char *
2114 ask_curve (int *algo, int both)
2115 {
2116   struct {
2117     const char *name;
2118     int available;
2119     int expert_only;
2120     int fix_curve;
2121     const char *pretty_name;
2122   } curves[] = {
2123 #if GPG_USE_EDDSA
2124     { "Curve25519",      0, 0, 1, "Curve 25519" },
2125 #endif
2126 #if GPG_USE_ECDSA || GPG_USE_ECDH
2127     { "NIST P-256",      0, 1, 0, },
2128     { "NIST P-384",      0, 0, 0, },
2129     { "NIST P-521",      0, 1, 0, },
2130     { "brainpoolP256r1", 0, 1, 0, "Brainpool P-256" },
2131     { "brainpoolP384r1", 0, 1, 0, "Brainpool P-384" },
2132     { "brainpoolP512r1", 0, 1, 0, "Brainpool P-512" },
2133     { "secp256k1",       0, 1, 0  },
2134 #endif
2135   };
2136   int idx;
2137   char *answer;
2138   char *result = NULL;
2139   gcry_sexp_t keyparms;
2140
2141   tty_printf (_("Please select which elliptic curve you want:\n"));
2142
2143  again:
2144   keyparms = NULL;
2145   for (idx=0; idx < DIM(curves); idx++)
2146     {
2147       int rc;
2148
2149       curves[idx].available = 0;
2150       if (!opt.expert && curves[idx].expert_only)
2151         continue;
2152
2153       /* FIXME: The strcmp below is a temporary hack during
2154          development.  It shall be removed as soon as we have proper
2155          Curve25519 support in Libgcrypt.  */
2156       gcry_sexp_release (keyparms);
2157       rc = gcry_sexp_build (&keyparms, NULL,
2158                             "(public-key(ecc(curve %s)))",
2159                             (!strcmp (curves[idx].name, "Curve25519")
2160                              ? "Ed25519" : curves[idx].name));
2161       if (rc)
2162         continue;
2163       if (!gcry_pk_get_curve (keyparms, 0, NULL))
2164         continue;
2165       if (both && curves[idx].fix_curve)
2166         {
2167           /* Both Curve 25519 keys are to be created.  Check that
2168              Libgcrypt also supports the real Curve25519.  */
2169           gcry_sexp_release (keyparms);
2170           rc = gcry_sexp_build (&keyparms, NULL,
2171                                 "(public-key(ecc(curve %s)))",
2172                                  curves[idx].name);
2173           if (rc)
2174             continue;
2175           if (!gcry_pk_get_curve (keyparms, 0, NULL))
2176             continue;
2177         }
2178
2179       curves[idx].available = 1;
2180       tty_printf ("   (%d) %s\n", idx + 1,
2181                   curves[idx].pretty_name?
2182                   curves[idx].pretty_name:curves[idx].name);
2183     }
2184   gcry_sexp_release (keyparms);
2185
2186
2187   for (;;)
2188     {
2189       answer = cpr_get ("keygen.curve", _("Your selection? "));
2190       cpr_kill_prompt ();
2191       idx = *answer? atoi (answer) : 1;
2192       if (*answer && !idx)
2193         {
2194           /* See whether the user entered the name of the curve.  */
2195           for (idx=0; idx < DIM(curves); idx++)
2196             {
2197               if (!opt.expert && curves[idx].expert_only)
2198                 continue;
2199               if (!stricmp (curves[idx].name, answer)
2200                   || (curves[idx].pretty_name
2201                       && !stricmp (curves[idx].pretty_name, answer)))
2202                 break;
2203             }
2204           if (idx == DIM(curves))
2205             idx = -1;
2206         }
2207       else
2208         idx--;
2209       xfree(answer);
2210       answer = NULL;
2211       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
2212         tty_printf (_("Invalid selection.\n"));
2213       else
2214         {
2215           if (curves[idx].fix_curve)
2216             {
2217               log_info ("WARNING: Curve25519 is not yet part of the"
2218                         " OpenPGP standard.\n");
2219
2220               if (!cpr_get_answer_is_yes("experimental_curve.override",
2221                                          "Use this curve anyway? (y/N) ")  )
2222                 goto again;
2223             }
2224
2225           /* If the user selected a signing algorithm and Curve25519
2226              we need to update the algo and and the curve name.  */
2227           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
2228               && curves[idx].fix_curve)
2229             {
2230               *algo = PUBKEY_ALGO_EDDSA;
2231               result = xstrdup ("Ed25519");
2232             }
2233           else
2234             result = xstrdup (curves[idx].name);
2235           break;
2236         }
2237     }
2238
2239   if (!result)
2240     result = xstrdup (curves[0].name);
2241
2242   return result;
2243 }
2244
2245
2246 /****************
2247  * Parse an expire string and return its value in seconds.
2248  * Returns (u32)-1 on error.
2249  * This isn't perfect since scan_isodatestr returns unix time, and
2250  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
2251  * Because of this, we only permit setting expirations up to 2106, but
2252  * OpenPGP could theoretically allow up to 2242.  I think we'll all
2253  * just cope for the next few years until we get a 64-bit time_t or
2254  * similar.
2255  */
2256 u32
2257 parse_expire_string( const char *string )
2258 {
2259   int mult;
2260   u32 seconds;
2261   u32 abs_date = 0;
2262   u32 curtime = make_timestamp ();
2263   time_t tt;
2264
2265   if (!*string)
2266     seconds = 0;
2267   else if (!strncmp (string, "seconds=", 8))
2268     seconds = atoi (string+8);
2269   else if ((abs_date = scan_isodatestr(string))
2270            && (abs_date+86400/2) > curtime)
2271     seconds = (abs_date+86400/2) - curtime;
2272   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
2273     seconds = (u32)tt - curtime;
2274   else if ((mult = check_valid_days (string)))
2275     seconds = atoi (string) * 86400L * mult;
2276   else
2277     seconds = (u32)(-1);
2278
2279   return seconds;
2280 }
2281
2282 /* Parsean Creation-Date string which is either "1986-04-26" or
2283    "19860426T042640".  Returns 0 on error. */
2284 static u32
2285 parse_creation_string (const char *string)
2286 {
2287   u32 seconds;
2288
2289   if (!*string)
2290     seconds = 0;
2291   else if ( !strncmp (string, "seconds=", 8) )
2292     seconds = atoi (string+8);
2293   else if ( !(seconds = scan_isodatestr (string)))
2294     {
2295       time_t tmp = isotime2epoch (string);
2296       seconds = (tmp == (time_t)(-1))? 0 : tmp;
2297     }
2298   return seconds;
2299 }
2300
2301
2302 /* object == 0 for a key, and 1 for a sig */
2303 u32
2304 ask_expire_interval(int object,const char *def_expire)
2305 {
2306     u32 interval;
2307     char *answer;
2308
2309     switch(object)
2310       {
2311       case 0:
2312         if(def_expire)
2313           BUG();
2314         tty_printf(_("Please specify how long the key should be valid.\n"
2315                      "         0 = key does not expire\n"
2316                      "      <n>  = key expires in n days\n"
2317                      "      <n>w = key expires in n weeks\n"
2318                      "      <n>m = key expires in n months\n"
2319                      "      <n>y = key expires in n years\n"));
2320         break;
2321
2322       case 1:
2323         if(!def_expire)
2324           BUG();
2325         tty_printf(_("Please specify how long the signature should be valid.\n"
2326                      "         0 = signature does not expire\n"
2327                      "      <n>  = signature expires in n days\n"
2328                      "      <n>w = signature expires in n weeks\n"
2329                      "      <n>m = signature expires in n months\n"
2330                      "      <n>y = signature expires in n years\n"));
2331         break;
2332
2333       default:
2334         BUG();
2335       }
2336
2337     /* Note: The elgamal subkey for DSA has no expiration date because
2338      * it must be signed with the DSA key and this one has the expiration
2339      * date */
2340
2341     answer = NULL;
2342     for(;;)
2343       {
2344         u32 curtime;
2345
2346         xfree(answer);
2347         if(object==0)
2348           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
2349         else
2350           {
2351             char *prompt;
2352
2353 #define PROMPTSTRING _("Signature is valid for? (%s) ")
2354             /* This will actually end up larger than necessary because
2355                of the 2 bytes for '%s' */
2356             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
2357             sprintf(prompt,PROMPTSTRING,def_expire);
2358 #undef PROMPTSTRING
2359
2360             answer = cpr_get("siggen.valid",prompt);
2361             xfree(prompt);
2362
2363             if(*answer=='\0')
2364               answer=xstrdup(def_expire);
2365           }
2366         cpr_kill_prompt();
2367         trim_spaces(answer);
2368         curtime = make_timestamp ();
2369         interval = parse_expire_string( answer );
2370         if( interval == (u32)-1 )
2371           {
2372             tty_printf(_("invalid value\n"));
2373             continue;
2374           }
2375
2376         if( !interval )
2377           {
2378             tty_printf((object==0)
2379                        ? _("Key does not expire at all\n")
2380                        : _("Signature does not expire at all\n"));
2381           }
2382         else
2383           {
2384             tty_printf(object==0
2385                        ? _("Key expires at %s\n")
2386                        : _("Signature expires at %s\n"),
2387                        asctimestamp((ulong)(curtime + interval) ) );
2388 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
2389             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2390               tty_printf (_("Your system can't display dates beyond 2038.\n"
2391                             "However, it will be correctly handled up to"
2392                             " 2106.\n"));
2393             else
2394 #endif /*SIZEOF_TIME_T*/
2395               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2396                 {
2397                   tty_printf (_("invalid value\n"));
2398                   continue;
2399                 }
2400           }
2401
2402         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2403                                                    _("Is this correct? (y/N) ")) )
2404           break;
2405       }
2406
2407     xfree(answer);
2408     return interval;
2409 }
2410
2411 u32
2412 ask_expiredate()
2413 {
2414     u32 x = ask_expire_interval(0,NULL);
2415     return x? make_timestamp() + x : 0;
2416 }
2417
2418
2419
2420 static PKT_user_id *
2421 uid_from_string (const char *string)
2422 {
2423   size_t n;
2424   PKT_user_id *uid;
2425
2426   n = strlen (string);
2427   uid = xmalloc_clear (sizeof *uid + n);
2428   uid->len = n;
2429   strcpy (uid->name, string);
2430   uid->ref = 1;
2431   return uid;
2432 }
2433
2434
2435 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2436    printed for use during a new key creation.  If KEYBLOCK is not NULL
2437    the function prevents the creation of an already existing user
2438    ID.  */
2439 static char *
2440 ask_user_id (int mode, KBNODE keyblock)
2441 {
2442     char *answer;
2443     char *aname, *acomment, *amail, *uid;
2444
2445     if ( !mode )
2446       {
2447         /* TRANSLATORS: This is the new string telling the user what
2448            gpg is now going to do (i.e. ask for the parts of the user
2449            ID).  Note that if you do not translate this string, a
2450            different string will be used used, which might still have
2451            a correct translation.  */
2452         const char *s1 =
2453           N_("\n"
2454              "GnuPG needs to construct a user ID to identify your key.\n"
2455              "\n");
2456         const char *s2 = _(s1);
2457
2458         if (!strcmp (s1, s2))
2459           {
2460             /* There is no translation for the string thus we to use
2461                the old info text.  gettext has no way to tell whether
2462                a translation is actually available, thus we need to
2463                to compare again. */
2464             /* TRANSLATORS: This string is in general not anymore used
2465                but you should keep your existing translation.  In case
2466                the new string is not translated this old string will
2467                be used. */
2468             const char *s3 = N_("\n"
2469 "You need a user ID to identify your key; "
2470                                         "the software constructs the user ID\n"
2471 "from the Real Name, Comment and Email Address in this form:\n"
2472 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2473             const char *s4 = _(s3);
2474             if (strcmp (s3, s4))
2475               s2 = s3; /* A translation exists - use it. */
2476           }
2477         tty_printf ("%s", s2) ;
2478       }
2479     uid = aname = acomment = amail = NULL;
2480     for(;;) {
2481         char *p;
2482         int fail=0;
2483
2484         if( !aname ) {
2485             for(;;) {
2486                 xfree(aname);
2487                 aname = cpr_get("keygen.name",_("Real name: "));
2488                 trim_spaces(aname);
2489                 cpr_kill_prompt();
2490
2491                 if( opt.allow_freeform_uid )
2492                     break;
2493
2494                 if( strpbrk( aname, "<>" ) )
2495                     tty_printf(_("Invalid character in name\n"));
2496                 else if( digitp(aname) )
2497                     tty_printf(_("Name may not start with a digit\n"));
2498                 else if( strlen(aname) < 5 )
2499                     tty_printf(_("Name must be at least 5 characters long\n"));
2500                 else
2501                     break;
2502             }
2503         }
2504         if( !amail ) {
2505             for(;;) {
2506                 xfree(amail);
2507                 amail = cpr_get("keygen.email",_("Email address: "));
2508                 trim_spaces(amail);
2509                 cpr_kill_prompt();
2510                 if( !*amail || opt.allow_freeform_uid )
2511                     break;   /* no email address is okay */
2512                 else if ( !is_valid_mailbox (amail) )
2513                     tty_printf(_("Not a valid email address\n"));
2514                 else
2515                     break;
2516             }
2517         }
2518         if( !acomment ) {
2519             for(;;) {
2520                 xfree(acomment);
2521                 acomment = cpr_get("keygen.comment",_("Comment: "));
2522                 trim_spaces(acomment);
2523                 cpr_kill_prompt();
2524                 if( !*acomment )
2525                     break;   /* no comment is okay */
2526                 else if( strpbrk( acomment, "()" ) )
2527                     tty_printf(_("Invalid character in comment\n"));
2528                 else
2529                     break;
2530             }
2531         }
2532
2533
2534         xfree(uid);
2535         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2536         p = stpcpy(p, aname );
2537         if( *acomment )
2538             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2539         if( *amail )
2540             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2541
2542         /* Append a warning if the RNG is switched into fake mode.  */
2543         if ( random_is_faked ()  )
2544           strcpy(p, " (insecure!)" );
2545
2546         /* print a note in case that UTF8 mapping has to be done */
2547         for(p=uid; *p; p++ ) {
2548             if( *p & 0x80 ) {
2549                 tty_printf(_("You are using the '%s' character set.\n"),
2550                            get_native_charset() );
2551                 break;
2552             }
2553         }
2554
2555         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2556
2557         if( !*amail && !opt.allow_freeform_uid
2558             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2559             fail = 1;
2560             tty_printf(_("Please don't put the email address "
2561                          "into the real name or the comment\n") );
2562         }
2563
2564         if (!fail && keyblock)
2565           {
2566             PKT_user_id *uidpkt = uid_from_string (uid);
2567             KBNODE node;
2568
2569             for (node=keyblock; node && !fail; node=node->next)
2570               if (!is_deleted_kbnode (node)
2571                   && node->pkt->pkttype == PKT_USER_ID
2572                   && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2573                 fail = 1;
2574             if (fail)
2575               tty_printf (_("Such a user ID already exists on this key!\n"));
2576             free_user_id (uidpkt);
2577           }
2578
2579         for(;;) {
2580             /* TRANSLATORS: These are the allowed answers in
2581                lower and uppercase.  Below you will find the matching
2582                string which should be translated accordingly and the
2583                letter changed to match the one in the answer string.
2584
2585                  n = Change name
2586                  c = Change comment
2587                  e = Change email
2588                  o = Okay (ready, continue)
2589                  q = Quit
2590              */
2591             const char *ansstr = _("NnCcEeOoQq");
2592
2593             if( strlen(ansstr) != 10 )
2594                 BUG();
2595             if( cpr_enabled() ) {
2596                 answer = xstrdup (ansstr + (fail?8:6));
2597                 answer[1] = 0;
2598             }
2599             else {
2600                 answer = cpr_get("keygen.userid.cmd", fail?
2601                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2602                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2603                 cpr_kill_prompt();
2604             }
2605             if( strlen(answer) > 1 )
2606                 ;
2607             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2608                 xfree(aname); aname = NULL;
2609                 break;
2610             }
2611             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2612                 xfree(acomment); acomment = NULL;
2613                 break;
2614             }
2615             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2616                 xfree(amail); amail = NULL;
2617                 break;
2618             }
2619             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2620                 if( fail ) {
2621                     tty_printf(_("Please correct the error first\n"));
2622                 }
2623                 else {
2624                     xfree(aname); aname = NULL;
2625                     xfree(acomment); acomment = NULL;
2626                     xfree(amail); amail = NULL;
2627                     break;
2628                 }
2629             }
2630             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2631                 xfree(aname); aname = NULL;
2632                 xfree(acomment); acomment = NULL;
2633                 xfree(amail); amail = NULL;
2634                 xfree(uid); uid = NULL;
2635                 break;
2636             }
2637             xfree(answer);
2638         }
2639         xfree(answer);
2640         if( !amail && !acomment && !amail )
2641             break;
2642         xfree(uid); uid = NULL;
2643     }
2644     if( uid ) {
2645         char *p = native_to_utf8( uid );
2646         xfree( uid );
2647         uid = p;
2648     }
2649     return uid;
2650 }
2651
2652
2653 /*  MODE  0 - standard
2654           1 - Ask for passphrase of the card backup key.  */
2655 static DEK *
2656 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2657 {
2658     DEK *dek = NULL;
2659     STRING2KEY *s2k;
2660     const char *errtext = NULL;
2661     const char *custdesc = NULL;
2662
2663     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2664
2665     if (mode == 1)
2666       custdesc = _("Please enter a passphrase to protect the off-card "
2667                    "backup of the new encryption key.");
2668
2669     s2k = xmalloc_secure( sizeof *s2k );
2670     for(;;) {
2671         s2k->mode = opt.s2k_mode;
2672         s2k->hash_algo = S2K_DIGEST_ALGO;
2673         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2674                                      errtext, custdesc, NULL, r_canceled);
2675         if (!dek && *r_canceled) {
2676             xfree(dek); dek = NULL;
2677             xfree(s2k); s2k = NULL;
2678             break;
2679         }
2680         else if( !dek ) {
2681             errtext = N_("passphrase not correctly repeated; try again");
2682             tty_printf(_("%s.\n"), _(errtext));
2683         }
2684         else if( !dek->keylen ) {
2685             xfree(dek); dek = NULL;
2686             xfree(s2k); s2k = NULL;
2687             tty_printf(_(
2688             "You don't want a passphrase - this is probably a *bad* idea!\n"
2689             "I will do it anyway.  You can change your passphrase at any time,\n"
2690             "using this program with the option \"--edit-key\".\n\n"));
2691             break;
2692         }
2693         else
2694             break; /* okay */
2695     }
2696     *ret_s2k = s2k;
2697     return dek;
2698 }
2699
2700
2701 /* Basic key generation.  Here we divert to the actual generation
2702    routines based on the requested algorithm.  */
2703 static int
2704 do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
2705            u32 timestamp, u32 expiredate, int is_subkey,
2706            int keygen_flags, char **cache_nonce_addr)
2707 {
2708   gpg_error_t err;
2709
2710   /* Fixme: The entropy collecting message should be moved to a
2711      libgcrypt progress handler.  */
2712   if (!opt.batch)
2713     tty_printf (_(
2714 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2715 "some other action (type on the keyboard, move the mouse, utilize the\n"
2716 "disks) during the prime generation; this gives the random number\n"
2717 "generator a better chance to gain enough entropy.\n") );
2718
2719   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2720     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2721                    keygen_flags, cache_nonce_addr);
2722   else if (algo == PUBKEY_ALGO_DSA)
2723     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2724                    keygen_flags, cache_nonce_addr);
2725   else if (algo == PUBKEY_ALGO_ECDSA
2726            || algo == PUBKEY_ALGO_EDDSA
2727            || algo == PUBKEY_ALGO_ECDH)
2728     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
2729                    keygen_flags, cache_nonce_addr);
2730   else if (algo == PUBKEY_ALGO_RSA)
2731     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2732                    keygen_flags, cache_nonce_addr);
2733   else
2734     BUG();
2735
2736   return err;
2737 }
2738
2739
2740 /* Generate a new user id packet or return NULL if canceled.  If
2741    KEYBLOCK is not NULL the function prevents the creation of an
2742    already existing user ID.  */
2743 PKT_user_id *
2744 generate_user_id (KBNODE keyblock)
2745 {
2746   char *p;
2747
2748   p = ask_user_id (1, keyblock);
2749   if (!p)
2750     return NULL;  /* Canceled. */
2751   return uid_from_string (p);
2752 }
2753
2754
2755 /* Append R to the linked list PARA.  */
2756 static void
2757 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
2758 {
2759   assert (para);
2760   while (para->next)
2761     para = para->next;
2762   para->next = r;
2763 }
2764
2765 /* Release the parameter list R.  */
2766 static void
2767 release_parameter_list (struct para_data_s *r)
2768 {
2769   struct para_data_s *r2;
2770
2771   for (; r ; r = r2)
2772     {
2773       r2 = r->next;
2774       if (r->key == pPASSPHRASE_DEK)
2775         xfree (r->u.dek);
2776       else if (r->key == pPASSPHRASE_S2K )
2777         xfree (r->u.s2k);
2778
2779       xfree (r);
2780     }
2781 }
2782
2783 static struct para_data_s *
2784 get_parameter( struct para_data_s *para, enum para_name key )
2785 {
2786     struct para_data_s *r;
2787
2788     for( r = para; r && r->key != key; r = r->next )
2789         ;
2790     return r;
2791 }
2792
2793 static const char *
2794 get_parameter_value( struct para_data_s *para, enum para_name key )
2795 {
2796     struct para_data_s *r = get_parameter( para, key );
2797     return (r && *r->u.value)? r->u.value : NULL;
2798 }
2799
2800 static int
2801 get_parameter_algo( struct para_data_s *para, enum para_name key,
2802                     int *r_default)
2803 {
2804   int i;
2805   struct para_data_s *r = get_parameter( para, key );
2806
2807   if (r_default)
2808     *r_default = 0;
2809
2810   if (!r)
2811     return -1;
2812
2813   if (!ascii_strcasecmp (r->u.value, "default"))
2814     {
2815       /* Note: If you change this default algo, remember to change it
2816          also in gpg.c:gpgconf_list.  */
2817       i = DEFAULT_STD_ALGO;
2818       if (r_default)
2819         *r_default = 1;
2820     }
2821   else if (digitp (r->u.value))
2822     i = atoi( r->u.value );
2823   else if (!strcmp (r->u.value, "ELG-E")
2824            || !strcmp (r->u.value, "ELG"))
2825     i = GCRY_PK_ELG_E;
2826   else
2827     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
2828
2829   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2830     i = 0; /* we don't want to allow generation of these algorithms */
2831   return i;
2832 }
2833
2834 /*
2835  * Parse the usage parameter and set the keyflags.  Returns -1 on
2836  * error, 0 for no usage given or 1 for usage available.
2837  */
2838 static int
2839 parse_parameter_usage (const char *fname,
2840                        struct para_data_s *para, enum para_name key)
2841 {
2842     struct para_data_s *r = get_parameter( para, key );
2843     char *p, *pn;
2844     unsigned int use;
2845
2846     if( !r )
2847         return 0; /* none (this is an optional parameter)*/
2848
2849     use = 0;
2850     pn = r->u.value;
2851     while ( (p = strsep (&pn, " \t,")) ) {
2852         if ( !*p)
2853             ;
2854         else if ( !ascii_strcasecmp (p, "sign") )
2855             use |= PUBKEY_USAGE_SIG;
2856         else if ( !ascii_strcasecmp (p, "encrypt") )
2857             use |= PUBKEY_USAGE_ENC;
2858         else if ( !ascii_strcasecmp (p, "auth") )
2859             use |= PUBKEY_USAGE_AUTH;
2860         else {
2861             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2862             return -1; /* error */
2863         }
2864     }
2865     r->u.usage = use;
2866     return 1;
2867 }
2868
2869 static int
2870 parse_revocation_key (const char *fname,
2871                       struct para_data_s *para, enum para_name key)
2872 {
2873   struct para_data_s *r = get_parameter( para, key );
2874   struct revocation_key revkey;
2875   char *pn;
2876   int i;
2877
2878   if( !r )
2879     return 0; /* none (this is an optional parameter) */
2880
2881   pn = r->u.value;
2882
2883   revkey.class=0x80;
2884   revkey.algid=atoi(pn);
2885   if(!revkey.algid)
2886     goto fail;
2887
2888   /* Skip to the fpr */
2889   while(*pn && *pn!=':')
2890     pn++;
2891
2892   if(*pn!=':')
2893     goto fail;
2894
2895   pn++;
2896
2897   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2898     {
2899       int c=hextobyte(pn);
2900       if(c==-1)
2901         goto fail;
2902
2903       revkey.fpr[i]=c;
2904     }
2905
2906   /* skip to the tag */
2907   while(*pn && *pn!='s' && *pn!='S')
2908     pn++;
2909
2910   if(ascii_strcasecmp(pn,"sensitive")==0)
2911     revkey.class|=0x40;
2912
2913   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2914
2915   return 0;
2916
2917   fail:
2918   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2919   return -1; /* error */
2920 }
2921
2922
2923 static u32
2924 get_parameter_u32( struct para_data_s *para, enum para_name key )
2925 {
2926   struct para_data_s *r = get_parameter( para, key );
2927
2928   if( !r )
2929     return 0;
2930   if( r->key == pKEYCREATIONDATE )
2931     return r->u.creation;
2932   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2933     return r->u.expire;
2934   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2935     return r->u.usage;
2936
2937   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2938 }
2939
2940 static unsigned int
2941 get_parameter_uint( struct para_data_s *para, enum para_name key )
2942 {
2943     return get_parameter_u32( para, key );
2944 }
2945
2946 static struct revocation_key *
2947 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2948 {
2949     struct para_data_s *r = get_parameter( para, key );
2950     return r? &r->u.revkey : NULL;
2951 }
2952
2953 static int
2954 proc_parameter_file( struct para_data_s *para, const char *fname,
2955                      struct output_control_s *outctrl, int card )
2956 {
2957   struct para_data_s *r;
2958   const char *s1, *s2, *s3;
2959   size_t n;
2960   char *p;
2961   int is_default = 0;
2962   int have_user_id = 0;
2963   int err, algo;
2964
2965   /* Check that we have all required parameters. */
2966   r = get_parameter( para, pKEYTYPE );
2967   if(r)
2968     {
2969       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2970       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2971         {
2972           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2973           return -1;
2974         }
2975     }
2976   else
2977     {
2978       log_error ("%s: no Key-Type specified\n",fname);
2979       return -1;
2980     }
2981
2982   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2983   if (!err)
2984     {
2985       /* Default to algo capabilities if key-usage is not provided and
2986          no default algorithm has been requested.  */
2987       r = xmalloc_clear(sizeof(*r));
2988       r->key = pKEYUSAGE;
2989       r->u.usage = (is_default
2990                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
2991                     : openpgp_pk_algo_usage(algo));
2992       append_to_parameter (para, r);
2993     }
2994   else if (err == -1)
2995     return -1;
2996   else
2997     {
2998       r = get_parameter (para, pKEYUSAGE);
2999       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3000         {
3001           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
3002                      fname, r->lnr, algo);
3003           return -1;
3004         }
3005     }
3006
3007   is_default = 0;
3008   r = get_parameter( para, pSUBKEYTYPE );
3009   if(r)
3010     {
3011       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
3012       if (openpgp_pk_test_algo (algo))
3013         {
3014           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3015           return -1;
3016         }
3017
3018       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
3019       if (!err)
3020         {
3021           /* Default to algo capabilities if subkey-usage is not
3022              provided */
3023           r = xmalloc_clear (sizeof(*r));
3024           r->key = pSUBKEYUSAGE;
3025           r->u.usage = (is_default
3026                         ? PUBKEY_USAGE_ENC
3027                         : openpgp_pk_algo_usage (algo));
3028           append_to_parameter (para, r);
3029         }
3030       else if (err == -1)
3031         return -1;
3032       else
3033         {
3034           r = get_parameter (para, pSUBKEYUSAGE);
3035           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3036             {
3037               log_error ("%s:%d: specified Subkey-Usage not allowed"
3038                          " for algo %d\n", fname, r->lnr, algo);
3039               return -1;
3040             }
3041         }
3042     }
3043
3044
3045   if( get_parameter_value( para, pUSERID ) )
3046     have_user_id=1;
3047   else
3048     {
3049       /* create the formatted user ID */
3050       s1 = get_parameter_value( para, pNAMEREAL );
3051       s2 = get_parameter_value( para, pNAMECOMMENT );
3052       s3 = get_parameter_value( para, pNAMEEMAIL );
3053       if( s1 || s2 || s3 )
3054         {
3055           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
3056           r = xmalloc_clear( sizeof *r + n + 20 );
3057           r->key = pUSERID;
3058           p = r->u.value;
3059           if( s1 )
3060             p = stpcpy(p, s1 );
3061           if( s2 )
3062             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
3063           if( s3 )
3064             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
3065           append_to_parameter (para, r);
3066           have_user_id=1;
3067         }
3068     }
3069
3070   if(!have_user_id)
3071     {
3072       log_error("%s: no User-ID specified\n",fname);
3073       return -1;
3074     }
3075
3076   /* Set preferences, if any. */
3077   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
3078
3079   /* Set keyserver, if any. */
3080   s1=get_parameter_value( para, pKEYSERVER );
3081   if(s1)
3082     {
3083       struct keyserver_spec *spec;
3084
3085       spec=parse_keyserver_uri(s1,1,NULL,0);
3086       if(spec)
3087         {
3088           free_keyserver_spec(spec);
3089           opt.def_keyserver_url=s1;
3090         }
3091       else
3092         {
3093           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
3094           return -1;
3095         }
3096     }
3097
3098   /* Set revoker, if any. */
3099   if (parse_revocation_key (fname, para, pREVOKER))
3100     return -1;
3101
3102   /* Make DEK and S2K from the Passphrase. */
3103   if (outctrl->ask_passphrase)
3104     {
3105       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
3106          feature is required so that GUIs are able to do a key
3107          creation but have gpg-agent ask for the passphrase.  */
3108       int canceled = 0;
3109       STRING2KEY *s2k;
3110       DEK *dek;
3111
3112       dek = do_ask_passphrase (&s2k, 0, &canceled);
3113       if (dek)
3114         {
3115           r = xmalloc_clear( sizeof *r );
3116           r->key = pPASSPHRASE_DEK;
3117           r->u.dek = dek;
3118           append_to_parameter (para, r);
3119           r = xmalloc_clear( sizeof *r );
3120           r->key = pPASSPHRASE_S2K;
3121           r->u.s2k = s2k;
3122           append_to_parameter (para, r);
3123         }
3124
3125       if (canceled)
3126         {
3127           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
3128           return -1;
3129         }
3130     }
3131   else
3132     {
3133       r = get_parameter( para, pPASSPHRASE );
3134       if ( r && *r->u.value )
3135         {
3136           /* We have a plain text passphrase - create a DEK from it.
3137            * It is a little bit ridiculous to keep it in secure memory
3138            * but because we do this always, why not here.  */
3139           STRING2KEY *s2k;
3140           DEK *dek;
3141
3142           s2k = xmalloc ( sizeof *s2k );
3143           s2k->mode = opt.s2k_mode;
3144           s2k->hash_algo = S2K_DIGEST_ALGO;
3145           set_next_passphrase ( r->u.value );
3146           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3147                                    NULL, NULL);
3148           if (!dek)
3149             {
3150               log_error ("%s:%d: error post processing the passphrase\n",
3151                          fname, r->lnr );
3152               xfree (s2k);
3153               return -1;
3154             }
3155           set_next_passphrase (NULL);
3156           memset (r->u.value, 0, strlen(r->u.value));
3157
3158           r = xmalloc_clear (sizeof *r);
3159           r->key = pPASSPHRASE_S2K;
3160           r->u.s2k = s2k;
3161           append_to_parameter (para, r);
3162           r = xmalloc_clear (sizeof *r);
3163           r->key = pPASSPHRASE_DEK;
3164           r->u.dek = dek;
3165           append_to_parameter (para, r);
3166         }
3167     }
3168
3169   /* Make KEYCREATIONDATE from Creation-Date.  */
3170   r = get_parameter (para, pCREATIONDATE);
3171   if (r && *r->u.value)
3172     {
3173       u32 seconds;
3174
3175       seconds = parse_creation_string (r->u.value);
3176       if (!seconds)
3177         {
3178           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
3179           return -1;
3180         }
3181       r->u.creation = seconds;
3182       r->key = pKEYCREATIONDATE;  /* Change that entry. */
3183     }
3184
3185   /* Make KEYEXPIRE from Expire-Date.  */
3186   r = get_parameter( para, pEXPIREDATE );
3187   if( r && *r->u.value )
3188     {
3189       u32 seconds;
3190
3191       seconds = parse_expire_string( r->u.value );
3192       if( seconds == (u32)-1 )
3193         {
3194           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
3195           return -1;
3196         }
3197       r->u.expire = seconds;
3198       r->key = pKEYEXPIRE;  /* change hat entry */
3199       /* also set it for the subkey */
3200       r = xmalloc_clear( sizeof *r + 20 );
3201       r->key = pSUBKEYEXPIRE;
3202       r->u.expire = seconds;
3203       append_to_parameter (para, r);
3204     }
3205
3206   do_generate_keypair( para, outctrl, card );
3207   return 0;
3208 }
3209
3210
3211 /****************
3212  * Kludge to allow non interactive key generation controlled
3213  * by a parameter file.
3214  * Note, that string parameters are expected to be in UTF-8
3215  */
3216 static void
3217 read_parameter_file( const char *fname )
3218 {
3219     static struct { const char *name;
3220                     enum para_name key;
3221     } keywords[] = {
3222         { "Key-Type",       pKEYTYPE},
3223         { "Key-Length",     pKEYLENGTH },
3224         { "Key-Curve",      pKEYCURVE },
3225         { "Key-Usage",      pKEYUSAGE },
3226         { "Subkey-Type",    pSUBKEYTYPE },
3227         { "Subkey-Length",  pSUBKEYLENGTH },
3228         { "Subkey-Curve",   pSUBKEYCURVE },
3229         { "Subkey-Usage",   pSUBKEYUSAGE },
3230         { "Name-Real",      pNAMEREAL },
3231         { "Name-Email",     pNAMEEMAIL },
3232         { "Name-Comment",   pNAMECOMMENT },
3233         { "Expire-Date",    pEXPIREDATE },
3234         { "Creation-Date",  pCREATIONDATE },
3235         { "Passphrase",     pPASSPHRASE },
3236         { "Preferences",    pPREFERENCES },
3237         { "Revoker",        pREVOKER },
3238         { "Handle",         pHANDLE },
3239         { "Keyserver",      pKEYSERVER },
3240         { NULL, 0 }
3241     };
3242     IOBUF fp;
3243     byte *line;
3244     unsigned int maxlen, nline;
3245     char *p;
3246     int lnr;
3247     const char *err = NULL;
3248     struct para_data_s *para, *r;
3249     int i;
3250     struct output_control_s outctrl;
3251
3252     memset( &outctrl, 0, sizeof( outctrl ) );
3253     outctrl.pub.afx = new_armor_context ();
3254
3255     if( !fname || !*fname)
3256       fname = "-";
3257
3258     fp = iobuf_open (fname);
3259     if (fp && is_secured_file (iobuf_get_fd (fp)))
3260       {
3261         iobuf_close (fp);
3262         fp = NULL;
3263         gpg_err_set_errno (EPERM);
3264       }
3265     if (!fp) {
3266       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
3267       return;
3268     }
3269     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
3270
3271     lnr = 0;
3272     err = NULL;
3273     para = NULL;
3274     maxlen = 1024;
3275     line = NULL;
3276     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
3277         char *keyword, *value;
3278
3279         lnr++;
3280         if( !maxlen ) {
3281             err = "line too long";
3282             break;
3283         }
3284         for( p = line; isspace(*(byte*)p); p++ )
3285             ;
3286         if( !*p || *p == '#' )
3287             continue;
3288         keyword = p;
3289         if( *keyword == '%' ) {
3290             for( ; !isspace(*(byte*)p); p++ )
3291                 ;
3292             if( *p )
3293                 *p++ = 0;
3294             for( ; isspace(*(byte*)p); p++ )
3295                 ;
3296             value = p;
3297             trim_trailing_ws( value, strlen(value) );
3298             if( !ascii_strcasecmp( keyword, "%echo" ) )
3299                 log_info("%s\n", value );
3300             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
3301                 outctrl.dryrun = 1;
3302             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
3303                 outctrl.ask_passphrase = 1;
3304             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
3305                 outctrl.ask_passphrase = 0;
3306             else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
3307                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
3308             else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
3309                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
3310             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
3311                 outctrl.lnr = lnr;
3312                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
3313                   print_status_key_not_created
3314                     (get_parameter_value (para, pHANDLE));
3315                 release_parameter_list( para );
3316                 para = NULL;
3317             }
3318             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
3319                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
3320                     ; /* still the same file - ignore it */
3321                 else {
3322                     xfree( outctrl.pub.newfname );
3323                     outctrl.pub.newfname = xstrdup( value );
3324                     outctrl.use_files = 1;
3325                 }
3326             }
3327             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
3328               /* Ignore this command.  */
3329             }
3330             else
3331                 log_info("skipping control '%s' (%s)\n", keyword, value );
3332
3333
3334             continue;
3335         }
3336
3337
3338         if( !(p = strchr( p, ':' )) || p == keyword ) {
3339             err = "missing colon";
3340             break;
3341         }
3342         if( *p )
3343             *p++ = 0;
3344         for( ; isspace(*(byte*)p); p++ )
3345             ;
3346         if( !*p ) {
3347             err = "missing argument";
3348             break;
3349         }
3350         value = p;
3351         trim_trailing_ws( value, strlen(value) );
3352
3353         for(i=0; keywords[i].name; i++ ) {
3354             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
3355                 break;
3356         }
3357         if( !keywords[i].name ) {
3358             err = "unknown keyword";
3359             break;
3360         }
3361         if( keywords[i].key != pKEYTYPE && !para ) {
3362             err = "parameter block does not start with \"Key-Type\"";
3363             break;
3364         }
3365
3366         if( keywords[i].key == pKEYTYPE && para ) {
3367             outctrl.lnr = lnr;
3368             if (proc_parameter_file( para, fname, &outctrl, 0 ))
3369               print_status_key_not_created
3370                 (get_parameter_value (para, pHANDLE));
3371             release_parameter_list( para );
3372             para = NULL;
3373         }
3374         else {
3375             for( r = para; r; r = r->next ) {
3376                 if( r->key == keywords[i].key )
3377                     break;
3378             }
3379             if( r ) {
3380                 err = "duplicate keyword";
3381                 break;
3382             }
3383         }
3384         r = xmalloc_clear( sizeof *r + strlen( value ) );
3385         r->lnr = lnr;
3386         r->key = keywords[i].key;
3387         strcpy( r->u.value, value );
3388         r->next = para;
3389         para = r;
3390     }
3391     if( err )
3392         log_error("%s:%d: %s\n", fname, lnr, err );
3393     else if( iobuf_error (fp) ) {
3394         log_error("%s:%d: read error\n", fname, lnr);
3395     }
3396     else if( para ) {
3397         outctrl.lnr = lnr;
3398         if (proc_parameter_file( para, fname, &outctrl, 0 ))
3399           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3400     }
3401
3402     if( outctrl.use_files ) { /* close open streams */
3403         iobuf_close( outctrl.pub.stream );
3404
3405         /* Must invalidate that ugly cache to actually close it.  */
3406         if (outctrl.pub.fname)
3407           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3408                        0, (char*)outctrl.pub.fname);
3409
3410         xfree( outctrl.pub.fname );
3411         xfree( outctrl.pub.newfname );
3412     }
3413
3414     release_parameter_list( para );
3415     iobuf_close (fp);
3416     release_armor_context (outctrl.pub.afx);
3417 }
3418
3419
3420 /* Helper for quick_generate_keypair.  */
3421 static struct para_data_s *
3422 quickgen_set_para (struct para_data_s *para, int for_subkey,
3423                    int algo, int nbits, const char *curve)
3424 {
3425   struct para_data_s *r;
3426
3427   r = xmalloc_clear (sizeof *r + 20);
3428   r->key = for_subkey? pSUBKEYUSAGE :  pKEYUSAGE;
3429   strcpy (r->u.value, for_subkey ? "encrypt" : "sign");
3430   r->next = para;
3431   para = r;
3432   r = xmalloc_clear (sizeof *r + 20);
3433   r->key = for_subkey? pSUBKEYTYPE : pKEYTYPE;
3434   sprintf (r->u.value, "%d", algo);
3435   r->next = para;
3436   para = r;
3437
3438   if (curve)
3439     {
3440       r = xmalloc_clear (sizeof *r + strlen (curve));
3441       r->key = for_subkey? pSUBKEYCURVE : pKEYCURVE;
3442       strcpy (r->u.value, curve);
3443       r->next = para;
3444       para = r;
3445     }
3446   else
3447     {
3448       r = xmalloc_clear (sizeof *r + 20);
3449       r->key = for_subkey? pSUBKEYLENGTH : pKEYLENGTH;
3450       sprintf (r->u.value, "%u", nbits);
3451       r->next = para;
3452       para = r;
3453     }
3454
3455   return para;
3456 }
3457
3458
3459 /*
3460  * Unattended generation of a standard key.
3461  */
3462 void
3463 quick_generate_keypair (const char *uid)
3464 {
3465   gpg_error_t err;
3466   struct para_data_s *para = NULL;
3467   struct para_data_s *r;
3468   struct output_control_s outctrl;
3469   int use_tty;
3470
3471   memset (&outctrl, 0, sizeof outctrl);
3472
3473   use_tty = (!opt.batch && !opt.answer_yes
3474              && !cpr_enabled ()
3475              && gnupg_isatty (fileno (stdin))
3476              && gnupg_isatty (fileno (stdout))
3477              && gnupg_isatty (fileno (stderr)));
3478
3479   r = xmalloc_clear (sizeof *r + strlen (uid));
3480   r->key = pUSERID;
3481   strcpy (r->u.value, uid);
3482   r->next = para;
3483   para = r;
3484
3485   uid = trim_spaces (r->u.value);
3486   if (!*uid || (!opt.allow_freeform_uid && !is_valid_user_id (uid)))
3487     {
3488       log_error (_("Key generation failed: %s\n"),
3489                  gpg_strerror (GPG_ERR_INV_USER_ID));
3490       goto leave;
3491     }
3492
3493   /* If gpg is directly used on the console ask whether a key with the
3494      given user id shall really be created.  */
3495   if (use_tty)
3496     {
3497       tty_printf (_("About to create a key for:\n    \"%s\"\n\n"), uid);
3498       if (!cpr_get_answer_is_yes_def ("quick_keygen.okay",
3499                                       _("Continue? (Y/n) "), 1))
3500         goto leave;
3501     }
3502
3503   /* Check whether such a user ID already exists.  */
3504   {
3505     KEYDB_HANDLE kdbhd;
3506     KEYDB_SEARCH_DESC desc;
3507
3508     memset (&desc, 0, sizeof desc);
3509     desc.mode = KEYDB_SEARCH_MODE_EXACT;
3510     desc.u.name = uid;
3511
3512     kdbhd = keydb_new ();
3513     err = keydb_search (kdbhd, &desc, 1, NULL);
3514     keydb_release (kdbhd);
3515     if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
3516       {
3517         log_info (_("A key for \"%s\" already exists\n"), uid);
3518         if (opt.answer_yes)
3519           ;
3520         else if (!use_tty
3521                  || !cpr_get_answer_is_yes_def ("quick_keygen.force",
3522                                                 _("Create anyway? (y/N) "), 0))
3523           {
3524             log_inc_errorcount ();  /* we used log_info */
3525             goto leave;
3526           }
3527         log_info (_("creating anyway\n"));
3528       }
3529   }
3530
3531   para = quickgen_set_para (para, 0, PUBKEY_ALGO_RSA, 2048, NULL);
3532   para = quickgen_set_para (para, 1, PUBKEY_ALGO_RSA, 2048, NULL);
3533   /* para = quickgen_set_para (para, 0, PUBKEY_ALGO_EDDSA, 0, "Ed25519"); */
3534   /* para = quickgen_set_para (para, 1, PUBKEY_ALGO_ECDH,  0, "Curve25519"); */
3535
3536   proc_parameter_file (para, "[internal]", &outctrl, 0);
3537  leave:
3538   release_parameter_list (para);
3539 }
3540
3541
3542 /*
3543  * Generate a keypair (fname is only used in batch mode) If
3544  * CARD_SERIALNO is not NULL the function will create the keys on an
3545  * OpenPGP Card.  If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
3546  * NOT NULL, the encryption key for the card is generated on the host,
3547  * imported to the card and a backup file created by gpg-agent.
3548  */
3549 void
3550 generate_keypair (ctrl_t ctrl, const char *fname, const char *card_serialno,
3551                   int card_backup_key)
3552 {
3553   unsigned int nbits;
3554   char *uid = NULL;
3555   int algo;
3556   unsigned int use;
3557   int both = 0;
3558   u32 expire;
3559   struct para_data_s *para = NULL;
3560   struct para_data_s *r;
3561   struct output_control_s outctrl;
3562
3563 #ifndef ENABLE_CARD_SUPPORT
3564   (void)card_backup_key;
3565 #endif
3566
3567   memset( &outctrl, 0, sizeof( outctrl ) );
3568
3569   if (opt.batch && card_serialno)
3570     {
3571       /* We don't yet support unattended key generation. */
3572       log_error (_("can't do this in batch mode\n"));
3573       return;
3574     }
3575
3576   if (opt.batch)
3577     {
3578       read_parameter_file( fname );
3579       return;
3580     }
3581
3582   if (card_serialno)
3583     {
3584 #ifdef ENABLE_CARD_SUPPORT
3585       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3586       r->key = pSERIALNO;
3587       strcpy( r->u.value, card_serialno);
3588       r->next = para;
3589       para = r;
3590
3591       algo = PUBKEY_ALGO_RSA;
3592
3593       r = xcalloc (1, sizeof *r + 20 );
3594       r->key = pKEYTYPE;
3595       sprintf( r->u.value, "%d", algo );
3596       r->next = para;
3597       para = r;
3598       r = xcalloc (1, sizeof *r + 20 );
3599       r->key = pKEYUSAGE;
3600       strcpy (r->u.value, "sign");
3601       r->next = para;
3602       para = r;
3603
3604       r = xcalloc (1, sizeof *r + 20 );
3605       r->key = pSUBKEYTYPE;
3606       sprintf( r->u.value, "%d", algo );
3607       r->next = para;
3608       para = r;
3609       r = xcalloc (1, sizeof *r + 20 );
3610       r->key = pSUBKEYUSAGE;
3611       strcpy (r->u.value, "encrypt");
3612       r->next = para;
3613       para = r;
3614
3615       r = xcalloc (1, sizeof *r + 20 );
3616       r->key = pAUTHKEYTYPE;
3617       sprintf( r->u.value, "%d", algo );
3618       r->next = para;
3619       para = r;
3620
3621       if (card_backup_key)
3622         {
3623           r = xcalloc (1, sizeof *r + 1);
3624           r->key = pCARDBACKUPKEY;
3625           strcpy (r->u.value, "1");
3626           r->next = para;
3627           para = r;
3628         }
3629 #endif /*ENABLE_CARD_SUPPORT*/
3630     }
3631   else
3632     {
3633       int subkey_algo;
3634       char *curve = NULL;
3635
3636       /* Fixme: To support creating a primary key by keygrip we better
3637          also define the keyword for the parameter file.  Note that
3638          the subkey case will never be asserted if a keygrip has been
3639          given.  */
3640       algo = ask_algo (ctrl, 0, &subkey_algo, &use, NULL);
3641       if (subkey_algo)
3642         {
3643           /* Create primary and subkey at once.  */
3644           both = 1;
3645           if (algo == PUBKEY_ALGO_ECDSA
3646               || algo == PUBKEY_ALGO_EDDSA
3647               || algo == PUBKEY_ALGO_ECDH)
3648             {
3649               curve = ask_curve (&algo, both);
3650               r = xmalloc_clear( sizeof *r + 20 );
3651               r->key = pKEYTYPE;
3652               sprintf( r->u.value, "%d", algo);
3653               r->next = para;
3654               para = r;
3655               nbits = 0;
3656               r = xmalloc_clear (sizeof *r + strlen (curve));
3657               r->key = pKEYCURVE;
3658               strcpy (r->u.value, curve);
3659               r->next = para;
3660               para = r;
3661             }
3662           else
3663             {
3664               r = xmalloc_clear( sizeof *r + 20 );
3665               r->key = pKEYTYPE;
3666               sprintf( r->u.value, "%d", algo);
3667               r->next = para;
3668               para = r;
3669               nbits = ask_keysize (algo, 0);
3670               r = xmalloc_clear( sizeof *r + 20 );
3671               r->key = pKEYLENGTH;
3672               sprintf( r->u.value, "%u", nbits);
3673               r->next = para;
3674               para = r;
3675             }
3676           r = xmalloc_clear( sizeof *r + 20 );
3677           r->key = pKEYUSAGE;
3678           strcpy( r->u.value, "sign" );
3679           r->next = para;
3680           para = r;
3681
3682           r = xmalloc_clear( sizeof *r + 20 );
3683           r->key = pSUBKEYTYPE;
3684           sprintf( r->u.value, "%d", subkey_algo);
3685           r->next = para;
3686           para = r;
3687           r = xmalloc_clear( sizeof *r + 20 );
3688           r->key = pSUBKEYUSAGE;
3689           strcpy( r->u.value, "encrypt" );
3690           r->next = para;
3691           para = r;
3692
3693           if (algo == PUBKEY_ALGO_ECDSA
3694               || algo == PUBKEY_ALGO_EDDSA
3695               || algo == PUBKEY_ALGO_ECDH)
3696             {
3697               if (algo == PUBKEY_ALGO_EDDSA
3698                   && subkey_algo == PUBKEY_ALGO_ECDH)
3699                 {
3700                   /* Need to switch to a different curve for the
3701                      encryption key.  */
3702                   xfree (curve);
3703                   curve = xstrdup ("Curve25519");
3704                 }
3705               r = xmalloc_clear (sizeof *r + strlen (curve));
3706               r->key = pSUBKEYCURVE;
3707               strcpy (r->u.value, curve);
3708               r->next = para;
3709               para = r;
3710             }
3711         }
3712       else /* Create only a single key.  */
3713         {
3714           /* For ECC we need to ask for the curve before storing the
3715              algo because ask_curve may change the algo.  */
3716           if (algo == PUBKEY_ALGO_ECDSA
3717               || algo == PUBKEY_ALGO_EDDSA
3718               || algo == PUBKEY_ALGO_ECDH)
3719             {
3720               curve = ask_curve (&algo, 0);
3721               nbits = 0;
3722               r = xmalloc_clear (sizeof *r + strlen (curve));
3723               r->key = pKEYCURVE;
3724               strcpy (r->u.value, curve);
3725               r->next = para;
3726               para = r;
3727             }
3728
3729           r = xmalloc_clear( sizeof *r + 20 );
3730           r->key = pKEYTYPE;
3731           sprintf( r->u.value, "%d", algo );
3732           r->next = para;
3733           para = r;
3734
3735           if (use)
3736             {
3737               r = xmalloc_clear( sizeof *r + 25 );
3738               r->key = pKEYUSAGE;
3739               sprintf( r->u.value, "%s%s%s",
3740                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3741                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3742                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3743               r->next = para;
3744               para = r;
3745             }
3746           nbits = 0;
3747         }
3748
3749       if (algo == PUBKEY_ALGO_ECDSA
3750           || algo == PUBKEY_ALGO_EDDSA
3751           || algo == PUBKEY_ALGO_ECDH)
3752         {
3753           /* The curve has already been set.  */
3754         }
3755       else
3756         {
3757           nbits = ask_keysize (both? subkey_algo : algo, nbits);
3758           r = xmalloc_clear( sizeof *r + 20 );
3759           r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3760           sprintf( r->u.value, "%u", nbits);
3761           r->next = para;
3762           para = r;
3763         }
3764
3765       xfree (curve);
3766     }
3767
3768   expire = ask_expire_interval(0,NULL);
3769   r = xmalloc_clear( sizeof *r + 20 );
3770   r->key = pKEYEXPIRE;
3771   r->u.expire = expire;
3772   r->next = para;
3773   para = r;
3774   r = xmalloc_clear( sizeof *r + 20 );
3775   r->key = pSUBKEYEXPIRE;
3776   r->u.expire = expire;
3777   r->next = para;
3778   para = r;
3779
3780   uid = ask_user_id (0, NULL);
3781   if( !uid )
3782     {
3783       log_error(_("Key generation canceled.\n"));
3784       release_parameter_list( para );
3785       return;
3786     }
3787   r = xmalloc_clear( sizeof *r + strlen(uid) );
3788   r->key = pUSERID;
3789   strcpy( r->u.value, uid );
3790   r->next = para;
3791   para = r;
3792
3793   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3794   release_parameter_list( para );
3795 }
3796
3797
3798 #if 0 /* not required */
3799 /* Generate a raw key and return it as a secret key packet.  The
3800    function will ask for the passphrase and return a protected as well
3801    as an unprotected copy of a new secret key packet.  0 is returned
3802    on success and the caller must then free the returned values.  */
3803 static int
3804 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3805                   PKT_secret_key **r_sk_unprotected,
3806                   PKT_secret_key **r_sk_protected)
3807 {
3808   int rc;
3809   DEK *dek = NULL;
3810   STRING2KEY *s2k = NULL;
3811   PKT_secret_key *sk = NULL;
3812   int i;
3813   size_t nskey, npkey;
3814   gcry_sexp_t s_parms, s_key;
3815   int canceled;
3816
3817   npkey = pubkey_get_npkey (algo);
3818   nskey = pubkey_get_nskey (algo);
3819   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3820
3821   if (nbits < 512)
3822     {
3823       nbits = 512;
3824       log_info (_("keysize invalid; using %u bits\n"), nbits );
3825     }
3826
3827   if ((nbits % 32))
3828     {
3829       nbits = ((nbits + 31) / 32) * 32;
3830       log_info(_("keysize rounded up to %u bits\n"), nbits );
3831     }
3832
3833   dek = do_ask_passphrase (&s2k, 1, &canceled);
3834   if (canceled)
3835     {
3836       rc = gpg_error (GPG_ERR_CANCELED);
3837       goto leave;
3838     }
3839
3840   sk = xmalloc_clear (sizeof *sk);
3841   sk->timestamp = created_at;
3842   sk->version = 4;
3843   sk->pubkey_algo = algo;
3844
3845   if ( !is_RSA (algo) )
3846     {
3847       log_error ("only RSA is supported for offline generated keys\n");
3848       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3849       goto leave;
3850     }
3851   rc = gcry_sexp_build (&s_parms, NULL,
3852                         "(genkey(rsa(nbits %d)))",
3853                         (int)nbits);
3854   if (rc)
3855     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3856   rc = gcry_pk_genkey (&s_key, s_parms);
3857   gcry_sexp_release (s_parms);
3858   if (rc)
3859     {
3860       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3861       goto leave;
3862     }
3863   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3864   gcry_sexp_release (s_key);
3865   if (rc)
3866     {
3867       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3868       goto leave;
3869     }
3870
3871   for (i=npkey; i < nskey; i++)
3872     sk->csum += checksum_mpi (sk->skey[i]);
3873
3874   if (r_sk_unprotected)
3875     *r_sk_unprotected = copy_secret_key (NULL, sk);
3876
3877   rc = genhelp_protect (dek, s2k, sk);
3878   if (rc)
3879     goto leave;
3880
3881   if (r_sk_protected)
3882     {
3883       *r_sk_protected = sk;
3884       sk = NULL;
3885     }
3886
3887  leave:
3888   if (sk)
3889     free_secret_key (sk);
3890   xfree (dek);
3891   xfree (s2k);
3892   return rc;
3893 }
3894 #endif /* ENABLE_CARD_SUPPORT */
3895
3896 /* Create and delete a dummy packet to start off a list of kbnodes. */
3897 static void
3898 start_tree(KBNODE *tree)
3899 {
3900   PACKET *pkt;
3901
3902   pkt=xmalloc_clear(sizeof(*pkt));
3903   pkt->pkttype=PKT_NONE;
3904   *tree=new_kbnode(pkt);
3905   delete_kbnode(*tree);
3906 }
3907
3908
3909 static void
3910 do_generate_keypair (struct para_data_s *para,
3911                      struct output_control_s *outctrl, int card)
3912 {
3913   gpg_error_t err;
3914   KBNODE pub_root = NULL;
3915   const char *s;
3916   PKT_public_key *pri_psk = NULL;
3917   PKT_public_key *sub_psk = NULL;
3918   struct revocation_key *revkey;
3919   int did_sub = 0;
3920   u32 timestamp;
3921   char *cache_nonce = NULL;
3922
3923   if (outctrl->dryrun)
3924     {
3925       log_info("dry-run mode - key generation skipped\n");
3926       return;
3927     }
3928
3929   if ( outctrl->use_files )
3930     {
3931       if ( outctrl->pub.newfname )
3932         {
3933           iobuf_close(outctrl->pub.stream);
3934           outctrl->pub.stream = NULL;
3935           if (outctrl->pub.fname)
3936             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3937                          0, (char*)outctrl->pub.fname);
3938           xfree( outctrl->pub.fname );
3939           outctrl->pub.fname =  outctrl->pub.newfname;
3940           outctrl->pub.newfname = NULL;
3941
3942           if (is_secured_filename (outctrl->pub.fname) )
3943             {
3944               outctrl->pub.stream = NULL;
3945               gpg_err_set_errno (EPERM);
3946             }
3947           else
3948             outctrl->pub.stream = iobuf_create (outctrl->pub.fname, 0);
3949           if (!outctrl->pub.stream)
3950             {
3951               log_error(_("can't create '%s': %s\n"), outctrl->pub.newfname,
3952                         strerror(errno) );
3953               return;
3954             }
3955           if (opt.armor)
3956             {
3957               outctrl->pub.afx->what = 1;
3958               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3959             }
3960         }
3961       assert( outctrl->pub.stream );
3962       if (opt.verbose)
3963         log_info (_("writing public key to '%s'\n"), outctrl->pub.fname );
3964     }
3965
3966
3967   /* We create the packets as a tree of kbnodes.  Because the
3968      structure we create is known in advance we simply generate a
3969      linked list.  The first packet is a dummy packet which we flag as
3970      deleted.  The very first packet must always be a KEY packet.  */
3971
3972   start_tree (&pub_root);
3973
3974   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3975   if (!timestamp)
3976     timestamp = make_timestamp ();
3977
3978   /* Note that, depending on the backend (i.e. the used scdaemon
3979      version), the card key generation may update TIMESTAMP for each
3980      key.  Thus we need to pass TIMESTAMP to all signing function to
3981      make sure that the binding signature is done using the timestamp
3982      of the corresponding (sub)key and not that of the primary key.
3983      An alternative implementation could tell the signing function the
3984      node of the subkey but that is more work than just to pass the
3985      current timestamp.  */
3986
3987   if (!card)
3988     err = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
3989                      get_parameter_uint( para, pKEYLENGTH ),
3990                      get_parameter_value (para, pKEYCURVE),
3991                      pub_root,
3992                      timestamp,
3993                      get_parameter_u32( para, pKEYEXPIRE ), 0,
3994                      outctrl->keygen_flags, &cache_nonce);
3995   else
3996     err = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root,
3997                         &timestamp,
3998                         get_parameter_u32 (para, pKEYEXPIRE));
3999
4000   /* Get the pointer to the generated public key packet.  */
4001   if (!err)
4002     {
4003       pri_psk = pub_root->next->pkt->pkt.public_key;
4004       assert (pri_psk);
4005     }
4006
4007   if (!err && (revkey = get_parameter_revkey (para, pREVOKER)))
4008     err = write_direct_sig (pub_root, pri_psk, revkey, timestamp, cache_nonce);
4009
4010   if (!err && (s = get_parameter_value (para, pUSERID)))
4011     {
4012       write_uid (pub_root, s );
4013       err = write_selfsigs (pub_root, pri_psk,
4014                             get_parameter_uint (para, pKEYUSAGE), timestamp,
4015                             cache_nonce);
4016     }
4017
4018   /* Write the auth key to the card before the encryption key.  This
4019      is a partial workaround for a PGP bug (as of this writing, all
4020      versions including 8.1), that causes it to try and encrypt to
4021      the most recent subkey regardless of whether that subkey is
4022      actually an encryption type.  In this case, the auth key is an
4023      RSA key so it succeeds. */
4024
4025   if (!err && card && get_parameter (para, pAUTHKEYTYPE))
4026     {
4027       err = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root,
4028                           &timestamp,
4029                           get_parameter_u32 (para, pKEYEXPIRE));
4030       if (!err)
4031         err = write_keybinding (pub_root, pri_psk, NULL,
4032                                 PUBKEY_USAGE_AUTH, timestamp, cache_nonce);
4033     }
4034
4035   if (!err && get_parameter (para, pSUBKEYTYPE))
4036     {
4037       sub_psk = NULL;
4038       if (!card)
4039         {
4040           err = do_create (get_parameter_algo (para, pSUBKEYTYPE, NULL),
4041                            get_parameter_uint (para, pSUBKEYLENGTH),
4042                            get_parameter_value (para, pSUBKEYCURVE),
4043                            pub_root,
4044                            timestamp,
4045                            get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
4046                            outctrl->keygen_flags, &cache_nonce);
4047           /* Get the pointer to the generated public subkey packet.  */
4048           if (!err)
4049             {
4050               kbnode_t node;
4051
4052               for (node = pub_root; node; node = node->next)
4053                 if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
4054                   sub_psk = node->pkt->pkt.public_key;
4055               assert (sub_psk);
4056             }
4057         }
4058       else
4059         {
4060           if ((s = get_parameter_value (para, pCARDBACKUPKEY)))
4061             {
4062               /* A backup of the encryption key has been requested.
4063                  Generate the key in software and import it then to
4064                  the card.  Write a backup file. */
4065               err = gen_card_key_with_backup
4066                 (PUBKEY_ALGO_RSA, 2, 0, pub_root, timestamp,
4067                  get_parameter_u32 (para, pKEYEXPIRE), para);
4068             }
4069           else
4070             {
4071               err = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root,
4072                                   &timestamp,
4073                                   get_parameter_u32 (para, pKEYEXPIRE));
4074             }
4075         }
4076
4077       if (!err)
4078         err = write_keybinding (pub_root, pri_psk, sub_psk,
4079                                 get_parameter_uint (para, pSUBKEYUSAGE),
4080                                 timestamp, cache_nonce);
4081       did_sub = 1;
4082     }
4083
4084   if (!err && outctrl->use_files)  /* Direct write to specified files.  */
4085     {
4086       err = write_keyblock (outctrl->pub.stream, pub_root);
4087       if (err)
4088         log_error ("can't write public key: %s\n", g10_errstr (err));
4089     }
4090   else if (!err) /* Write to the standard keyrings.  */
4091     {
4092       KEYDB_HANDLE pub_hd = keydb_new ();
4093
4094       err = keydb_locate_writable (pub_hd, NULL);
4095       if (err)
4096         log_error (_("no writable public keyring found: %s\n"),
4097                    g10_errstr (err));
4098
4099       if (!err && opt.verbose)
4100         {
4101           log_info (_("writing public key to '%s'\n"),
4102                     keydb_get_resource_name (pub_hd));
4103         }
4104
4105       if (!err)
4106         {
4107           err = keydb_insert_keyblock (pub_hd, pub_root);
4108           if (err)
4109             log_error (_("error writing public keyring '%s': %s\n"),
4110                        keydb_get_resource_name (pub_hd), g10_errstr(err));
4111         }
4112
4113       keydb_release (pub_hd);
4114
4115       if (!err)
4116         {
4117           int no_enc_rsa;
4118           PKT_public_key *pk;
4119
4120           no_enc_rsa = ((get_parameter_algo (para, pKEYTYPE, NULL)
4121                          == PUBKEY_ALGO_RSA)
4122                         && get_parameter_uint (para, pKEYUSAGE)
4123                         && !((get_parameter_uint (para, pKEYUSAGE)
4124                               & PUBKEY_USAGE_ENC)) );
4125
4126           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
4127
4128           keyid_from_pk (pk, pk->main_keyid);
4129           register_trusted_keyid (pk->main_keyid);
4130
4131           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
4132                                   | TRUST_ULTIMATE ));
4133
4134           gen_standard_revoke (pk, cache_nonce);
4135
4136           if (!opt.batch)
4137             {
4138               tty_printf (_("public and secret key created and signed.\n") );
4139               tty_printf ("\n");
4140               list_keyblock (pub_root, 0, 1, 1, NULL);
4141             }
4142
4143
4144           if (!opt.batch
4145               && (get_parameter_algo (para, pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
4146                   || no_enc_rsa )
4147               && !get_parameter (para, pSUBKEYTYPE) )
4148             {
4149               tty_printf(_("Note that this key cannot be used for "
4150                            "encryption.  You may want to use\n"
4151                            "the command \"--edit-key\" to generate a "
4152                            "subkey for this purpose.\n") );
4153             }
4154         }
4155     }
4156
4157   if (err)
4158     {
4159       if (opt.batch)
4160         log_error ("key generation failed: %s\n", g10_errstr(err) );
4161       else
4162         tty_printf (_("Key generation failed: %s\n"), g10_errstr(err) );
4163       write_status_error (card? "card_key_generate":"key_generate", err);
4164       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
4165     }
4166   else
4167     {
4168       PKT_public_key *pk = find_kbnode (pub_root,
4169                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
4170       print_status_key_created (did_sub? 'B':'P', pk,
4171                                 get_parameter_value (para, pHANDLE));
4172     }
4173
4174   release_kbnode (pub_root);
4175   xfree (cache_nonce);
4176 }
4177
4178
4179 /* Add a new subkey to an existing key.  Returns 0 if a new key has
4180    been generated and put into the keyblocks.  */
4181 gpg_error_t
4182 generate_subkeypair (ctrl_t ctrl, kbnode_t keyblock)
4183 {
4184   gpg_error_t err = 0;
4185   kbnode_t node;
4186   PKT_public_key *pri_psk = NULL;
4187   PKT_public_key *sub_psk = NULL;
4188   int algo;
4189   unsigned int use;
4190   u32 expire;
4191   unsigned int nbits = 0;
4192   char *curve = NULL;
4193   u32 cur_time;
4194   char *hexgrip = NULL;
4195   char *serialno = NULL;
4196
4197   /* Break out the primary key.  */
4198   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
4199   if (!node)
4200     {
4201       log_error ("Oops; primary key missing in keyblock!\n");
4202       err = gpg_error (GPG_ERR_BUG);
4203       goto leave;
4204     }
4205   pri_psk = node->pkt->pkt.public_key;
4206
4207   cur_time = make_timestamp ();
4208
4209   if (pri_psk->timestamp > cur_time)
4210     {
4211       ulong d = pri_psk->timestamp - cur_time;
4212       log_info ( d==1 ? _("key has been created %lu second "
4213                           "in future (time warp or clock problem)\n")
4214                  : _("key has been created %lu seconds "
4215                      "in future (time warp or clock problem)\n"), d );
4216       if (!opt.ignore_time_conflict)
4217         {
4218           err = gpg_error (GPG_ERR_TIME_CONFLICT);
4219           goto leave;
4220         }
4221     }
4222
4223   if (pri_psk->version < 4)
4224     {
4225       log_info (_("NOTE: creating subkeys for v3 keys "
4226                   "is not OpenPGP compliant\n"));
4227       err = gpg_error (GPG_ERR_CONFLICT);
4228       goto leave;
4229     }
4230
4231   err = hexkeygrip_from_pk (pri_psk, &hexgrip);
4232   if (err)
4233     goto leave;
4234   if (agent_get_keyinfo (NULL, hexgrip, &serialno))
4235     {
4236       tty_printf (_("Secret parts of primary key are not available.\n"));
4237       goto leave;
4238     }
4239   if (serialno)
4240     tty_printf (_("Secret parts of primary key are stored on-card.\n"));
4241
4242   xfree (hexgrip);
4243   hexgrip = NULL;
4244   algo = ask_algo (ctrl, 1, NULL, &use, &hexgrip);
4245   assert (algo);
4246
4247   if (hexgrip)
4248     nbits = 0;
4249   else if (algo == PUBKEY_ALGO_ECDSA
4250            || algo == PUBKEY_ALGO_EDDSA
4251            || algo == PUBKEY_ALGO_ECDH)
4252     curve = ask_curve (&algo, 0);
4253   else
4254     nbits = ask_keysize (algo, 0);
4255
4256   expire = ask_expire_interval (0, NULL);
4257   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
4258                                                _("Really create? (y/N) ")))
4259     {
4260       err = gpg_error (GPG_ERR_CANCELED);
4261       goto leave;
4262     }
4263
4264   if (hexgrip)
4265     err = do_create_from_keygrip (ctrl, algo, hexgrip,
4266                                   keyblock, cur_time, expire, 1);
4267   else
4268     err = do_create (algo, nbits, curve,
4269                      keyblock, cur_time, expire, 1, 0, NULL);
4270   if (err)
4271     goto leave;
4272
4273   /* Get the pointer to the generated public subkey packet.  */
4274   for (node = keyblock; node; node = node->next)
4275     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
4276       sub_psk = node->pkt->pkt.public_key;
4277
4278   /* Write the binding signature.  */
4279   err = write_keybinding (keyblock, pri_psk, sub_psk, use, cur_time, NULL);
4280   if (err)
4281     goto leave;
4282
4283   write_status_text (STATUS_KEY_CREATED, "S");
4284
4285  leave:
4286   xfree (curve);
4287   xfree (hexgrip);
4288   xfree (serialno);
4289   if (err)