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