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