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