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