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