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