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