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