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