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