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