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