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