1cf8648135477bb9e53fa47f467d14fe24046452
[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   struct {
2147     const char *name;
2148     int available;
2149     int expert_only;
2150     int fix_curve;
2151     const char *pretty_name;
2152   } curves[] = {
2153 #if GPG_USE_EDDSA
2154     { "Curve25519",      0, 0, 1, "Curve 25519" },
2155 #endif
2156 #if GPG_USE_ECDSA || GPG_USE_ECDH
2157     { "NIST P-256",      0, 1, 0, },
2158     { "NIST P-384",      0, 0, 0, },
2159     { "NIST P-521",      0, 1, 0, },
2160     { "brainpoolP256r1", 0, 1, 0, "Brainpool P-256" },
2161     { "brainpoolP384r1", 0, 1, 0, "Brainpool P-384" },
2162     { "brainpoolP512r1", 0, 1, 0, "Brainpool P-512" },
2163     { "secp256k1",       0, 1, 0  },
2164 #endif
2165   };
2166   int idx;
2167   char *answer;
2168   char *result = NULL;
2169   gcry_sexp_t keyparms;
2170
2171   tty_printf (_("Please select which elliptic curve you want:\n"));
2172
2173  again:
2174   keyparms = NULL;
2175   for (idx=0; idx < DIM(curves); idx++)
2176     {
2177       int rc;
2178
2179       curves[idx].available = 0;
2180       if (!opt.expert && curves[idx].expert_only)
2181         continue;
2182
2183       /* FIXME: The strcmp below is a temporary hack during
2184          development.  It shall be removed as soon as we have proper
2185          Curve25519 support in Libgcrypt.  */
2186       gcry_sexp_release (keyparms);
2187       rc = gcry_sexp_build (&keyparms, NULL,
2188                             "(public-key(ecc(curve %s)))",
2189                             (!strcmp (curves[idx].name, "Curve25519")
2190                              ? "Ed25519" : curves[idx].name));
2191       if (rc)
2192         continue;
2193       if (!gcry_pk_get_curve (keyparms, 0, NULL))
2194         continue;
2195       if (subkey_algo && curves[idx].fix_curve)
2196         {
2197           /* Both Curve 25519 keys are to be created.  Check that
2198              Libgcrypt also supports the real Curve25519.  */
2199           gcry_sexp_release (keyparms);
2200           rc = gcry_sexp_build (&keyparms, NULL,
2201                                 "(public-key(ecc(curve %s)))",
2202                                  curves[idx].name);
2203           if (rc)
2204             continue;
2205           if (!gcry_pk_get_curve (keyparms, 0, NULL))
2206             continue;
2207         }
2208
2209       curves[idx].available = 1;
2210       tty_printf ("   (%d) %s\n", idx + 1,
2211                   curves[idx].pretty_name?
2212                   curves[idx].pretty_name:curves[idx].name);
2213     }
2214   gcry_sexp_release (keyparms);
2215
2216
2217   for (;;)
2218     {
2219       answer = cpr_get ("keygen.curve", _("Your selection? "));
2220       cpr_kill_prompt ();
2221       idx = *answer? atoi (answer) : 1;
2222       if (*answer && !idx)
2223         {
2224           /* See whether the user entered the name of the curve.  */
2225           for (idx=0; idx < DIM(curves); idx++)
2226             {
2227               if (!opt.expert && curves[idx].expert_only)
2228                 continue;
2229               if (!stricmp (curves[idx].name, answer)
2230                   || (curves[idx].pretty_name
2231                       && !stricmp (curves[idx].pretty_name, answer)))
2232                 break;
2233             }
2234           if (idx == DIM(curves))
2235             idx = -1;
2236         }
2237       else
2238         idx--;
2239       xfree(answer);
2240       answer = NULL;
2241       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
2242         tty_printf (_("Invalid selection.\n"));
2243       else
2244         {
2245           if (curves[idx].fix_curve)
2246             {
2247               log_info ("WARNING: Curve25519 is not yet part of the"
2248                         " OpenPGP standard.\n");
2249
2250               if (!cpr_get_answer_is_yes("experimental_curve.override",
2251                                          "Use this curve anyway? (y/N) ")  )
2252                 goto again;
2253             }
2254
2255           /* If the user selected a signing algorithm and Curve25519
2256              we need to update the algo and and the curve name.  */
2257           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
2258               && curves[idx].fix_curve)
2259             {
2260               if (subkey_algo && *subkey_algo == PUBKEY_ALGO_ECDSA)
2261                 *subkey_algo = PUBKEY_ALGO_EDDSA;
2262               *algo = PUBKEY_ALGO_EDDSA;
2263               result = xstrdup ("Ed25519");
2264             }
2265           else
2266             result = xstrdup (curves[idx].name);
2267           break;
2268         }
2269     }
2270
2271   if (!result)
2272     result = xstrdup (curves[0].name);
2273
2274   return result;
2275 }
2276
2277
2278 /****************
2279  * Parse an expire string and return its value in seconds.
2280  * Returns (u32)-1 on error.
2281  * This isn't perfect since scan_isodatestr returns unix time, and
2282  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
2283  * Because of this, we only permit setting expirations up to 2106, but
2284  * OpenPGP could theoretically allow up to 2242.  I think we'll all
2285  * just cope for the next few years until we get a 64-bit time_t or
2286  * similar.
2287  */
2288 u32
2289 parse_expire_string( const char *string )
2290 {
2291   int mult;
2292   u32 seconds;
2293   u32 abs_date = 0;
2294   u32 curtime = make_timestamp ();
2295   time_t tt;
2296
2297   if (!*string)
2298     seconds = 0;
2299   else if (!strncmp (string, "seconds=", 8))
2300     seconds = atoi (string+8);
2301   else if ((abs_date = scan_isodatestr(string))
2302            && (abs_date+86400/2) > curtime)
2303     seconds = (abs_date+86400/2) - curtime;
2304   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
2305     seconds = (u32)tt - curtime;
2306   else if ((mult = check_valid_days (string)))
2307     seconds = atoi (string) * 86400L * mult;
2308   else
2309     seconds = (u32)(-1);
2310
2311   return seconds;
2312 }
2313
2314 /* Parsean Creation-Date string which is either "1986-04-26" or
2315    "19860426T042640".  Returns 0 on error. */
2316 static u32
2317 parse_creation_string (const char *string)
2318 {
2319   u32 seconds;
2320
2321   if (!*string)
2322     seconds = 0;
2323   else if ( !strncmp (string, "seconds=", 8) )
2324     seconds = atoi (string+8);
2325   else if ( !(seconds = scan_isodatestr (string)))
2326     {
2327       time_t tmp = isotime2epoch (string);
2328       seconds = (tmp == (time_t)(-1))? 0 : tmp;
2329     }
2330   return seconds;
2331 }
2332
2333
2334 /* object == 0 for a key, and 1 for a sig */
2335 u32
2336 ask_expire_interval(int object,const char *def_expire)
2337 {
2338     u32 interval;
2339     char *answer;
2340
2341     switch(object)
2342       {
2343       case 0:
2344         if(def_expire)
2345           BUG();
2346         tty_printf(_("Please specify how long the key should be valid.\n"
2347                      "         0 = key does not expire\n"
2348                      "      <n>  = key expires in n days\n"
2349                      "      <n>w = key expires in n weeks\n"
2350                      "      <n>m = key expires in n months\n"
2351                      "      <n>y = key expires in n years\n"));
2352         break;
2353
2354       case 1:
2355         if(!def_expire)
2356           BUG();
2357         tty_printf(_("Please specify how long the signature should be valid.\n"
2358                      "         0 = signature does not expire\n"
2359                      "      <n>  = signature expires in n days\n"
2360                      "      <n>w = signature expires in n weeks\n"
2361                      "      <n>m = signature expires in n months\n"
2362                      "      <n>y = signature expires in n years\n"));
2363         break;
2364
2365       default:
2366         BUG();
2367       }
2368
2369     /* Note: The elgamal subkey for DSA has no expiration date because
2370      * it must be signed with the DSA key and this one has the expiration
2371      * date */
2372
2373     answer = NULL;
2374     for(;;)
2375       {
2376         u32 curtime;
2377
2378         xfree(answer);
2379         if(object==0)
2380           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
2381         else
2382           {
2383             char *prompt;
2384
2385 #define PROMPTSTRING _("Signature is valid for? (%s) ")
2386             /* This will actually end up larger than necessary because
2387                of the 2 bytes for '%s' */
2388             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
2389             sprintf(prompt,PROMPTSTRING,def_expire);
2390 #undef PROMPTSTRING
2391
2392             answer = cpr_get("siggen.valid",prompt);
2393             xfree(prompt);
2394
2395             if(*answer=='\0')
2396               answer=xstrdup(def_expire);
2397           }
2398         cpr_kill_prompt();
2399         trim_spaces(answer);
2400         curtime = make_timestamp ();
2401         interval = parse_expire_string( answer );
2402         if( interval == (u32)-1 )
2403           {
2404             tty_printf(_("invalid value\n"));
2405             continue;
2406           }
2407
2408         if( !interval )
2409           {
2410             tty_printf((object==0)
2411                        ? _("Key does not expire at all\n")
2412                        : _("Signature does not expire at all\n"));
2413           }
2414         else
2415           {
2416             tty_printf(object==0
2417                        ? _("Key expires at %s\n")
2418                        : _("Signature expires at %s\n"),
2419                        asctimestamp((ulong)(curtime + interval) ) );
2420 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
2421             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2422               tty_printf (_("Your system can't display dates beyond 2038.\n"
2423                             "However, it will be correctly handled up to"
2424                             " 2106.\n"));
2425             else
2426 #endif /*SIZEOF_TIME_T*/
2427               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2428                 {
2429                   tty_printf (_("invalid value\n"));
2430                   continue;
2431                 }
2432           }
2433
2434         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2435                                                    _("Is this correct? (y/N) ")) )
2436           break;
2437       }
2438
2439     xfree(answer);
2440     return interval;
2441 }
2442
2443 u32
2444 ask_expiredate()
2445 {
2446     u32 x = ask_expire_interval(0,NULL);
2447     return x? make_timestamp() + x : 0;
2448 }
2449
2450
2451
2452 static PKT_user_id *
2453 uid_from_string (const char *string)
2454 {
2455   size_t n;
2456   PKT_user_id *uid;
2457
2458   n = strlen (string);
2459   uid = xmalloc_clear (sizeof *uid + n);
2460   uid->len = n;
2461   strcpy (uid->name, string);
2462   uid->ref = 1;
2463   return uid;
2464 }
2465
2466
2467 /* Return true if the user id UID already exists in the keyblock.  */
2468 static int
2469 uid_already_in_keyblock (kbnode_t keyblock, const char *uid)
2470 {
2471   PKT_user_id *uidpkt = uid_from_string (uid);
2472   kbnode_t node;
2473   int result = 0;
2474
2475   for (node=keyblock; node && !result; node=node->next)
2476     if (!is_deleted_kbnode (node)
2477         && node->pkt->pkttype == PKT_USER_ID
2478         && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2479       result = 1;
2480   free_user_id (uidpkt);
2481   return result;
2482 }
2483
2484
2485 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2486    printed for use during a new key creation.  If KEYBLOCK is not NULL
2487    the function prevents the creation of an already existing user
2488    ID.  IF FULL is not set some prompts are not shown.  */
2489 static char *
2490 ask_user_id (int mode, int full, KBNODE keyblock)
2491 {
2492     char *answer;
2493     char *aname, *acomment, *amail, *uid;
2494
2495     if ( !mode )
2496       {
2497         /* TRANSLATORS: This is the new string telling the user what
2498            gpg is now going to do (i.e. ask for the parts of the user
2499            ID).  Note that if you do not translate this string, a
2500            different string will be used, which might still have
2501            a correct translation.  */
2502         const char *s1 =
2503           N_("\n"
2504              "GnuPG needs to construct a user ID to identify your key.\n"
2505              "\n");
2506         const char *s2 = _(s1);
2507
2508         if (!strcmp (s1, s2))
2509           {
2510             /* There is no translation for the string thus we to use
2511                the old info text.  gettext has no way to tell whether
2512                a translation is actually available, thus we need to
2513                to compare again. */
2514             /* TRANSLATORS: This string is in general not anymore used
2515                but you should keep your existing translation.  In case
2516                the new string is not translated this old string will
2517                be used. */
2518             const char *s3 = N_("\n"
2519 "You need a user ID to identify your key; "
2520                                         "the software constructs the user ID\n"
2521 "from the Real Name, Comment and Email Address in this form:\n"
2522 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2523             const char *s4 = _(s3);
2524             if (strcmp (s3, s4))
2525               s2 = s3; /* A translation exists - use it. */
2526           }
2527         tty_printf ("%s", s2) ;
2528       }
2529     uid = aname = acomment = amail = NULL;
2530     for(;;) {
2531         char *p;
2532         int fail=0;
2533
2534         if( !aname ) {
2535             for(;;) {
2536                 xfree(aname);
2537                 aname = cpr_get("keygen.name",_("Real name: "));
2538                 trim_spaces(aname);
2539                 cpr_kill_prompt();
2540
2541                 if( opt.allow_freeform_uid )
2542                     break;
2543
2544                 if( strpbrk( aname, "<>" ) )
2545                   {
2546                     tty_printf(_("Invalid character in name\n"));
2547                     tty_printf(_("The characters '%s' and '%s' may not "
2548                                  "appear in name\n"), "<", ">");
2549                   }
2550                 else if( digitp(aname) )
2551                     tty_printf(_("Name may not start with a digit\n"));
2552                 else if (*aname && strlen (aname) < 5)
2553                   {
2554                     tty_printf(_("Name must be at least 5 characters long\n"));
2555                     /* However, we allow an empty name.  */
2556                   }
2557                 else
2558                     break;
2559             }
2560         }
2561         if( !amail ) {
2562             for(;;) {
2563                 xfree(amail);
2564                 amail = cpr_get("keygen.email",_("Email address: "));
2565                 trim_spaces(amail);
2566                 cpr_kill_prompt();
2567                 if( !*amail || opt.allow_freeform_uid )
2568                     break;   /* no email address is okay */
2569                 else if ( !is_valid_mailbox (amail) )
2570                     tty_printf(_("Not a valid email address\n"));
2571                 else
2572                     break;
2573             }
2574         }
2575         if (!acomment) {
2576           if (full) {
2577             for(;;) {
2578                 xfree(acomment);
2579                 acomment = cpr_get("keygen.comment",_("Comment: "));
2580                 trim_spaces(acomment);
2581                 cpr_kill_prompt();
2582                 if( !*acomment )
2583                     break;   /* no comment is okay */
2584                 else if( strpbrk( acomment, "()" ) )
2585                     tty_printf(_("Invalid character in comment\n"));
2586                 else
2587                     break;
2588             }
2589           }
2590           else {
2591             xfree (acomment);
2592             acomment = xstrdup ("");
2593           }
2594         }
2595
2596
2597         xfree(uid);
2598         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2599         if (!*aname && *amail && !*acomment && !random_is_faked ())
2600           { /* Empty name and comment but with mail address.  Use
2601                simplified form with only the non-angle-bracketed mail
2602                address.  */
2603             p = stpcpy (p, amail);
2604           }
2605         else
2606           {
2607             p = stpcpy (p, aname );
2608             if (*acomment)
2609               p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2610             if (*amail)
2611               p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2612           }
2613
2614         /* Append a warning if the RNG is switched into fake mode.  */
2615         if ( random_is_faked ()  )
2616           strcpy(p, " (insecure!)" );
2617
2618         /* print a note in case that UTF8 mapping has to be done */
2619         for(p=uid; *p; p++ ) {
2620             if( *p & 0x80 ) {
2621                 tty_printf(_("You are using the '%s' character set.\n"),
2622                            get_native_charset() );
2623                 break;
2624             }
2625         }
2626
2627         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2628
2629         if( !*amail && !opt.allow_freeform_uid
2630             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2631             fail = 1;
2632             tty_printf(_("Please don't put the email address "
2633                          "into the real name or the comment\n") );
2634         }
2635
2636         if (!fail && keyblock)
2637           {
2638             if (uid_already_in_keyblock (keyblock, uid))
2639               {
2640                 tty_printf (_("Such a user ID already exists on this key!\n"));
2641                 fail = 1;
2642               }
2643           }
2644
2645         for(;;) {
2646             /* TRANSLATORS: These are the allowed answers in
2647                lower and uppercase.  Below you will find the matching
2648                string which should be translated accordingly and the
2649                letter changed to match the one in the answer string.
2650
2651                  n = Change name
2652                  c = Change comment
2653                  e = Change email
2654                  o = Okay (ready, continue)
2655                  q = Quit
2656              */
2657             const char *ansstr = _("NnCcEeOoQq");
2658
2659             if( strlen(ansstr) != 10 )
2660                 BUG();
2661             if( cpr_enabled() ) {
2662                 answer = xstrdup (ansstr + (fail?8:6));
2663                 answer[1] = 0;
2664             }
2665             else if (full) {
2666                 answer = cpr_get("keygen.userid.cmd", fail?
2667                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2668                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2669                 cpr_kill_prompt();
2670             }
2671             else {
2672                 answer = cpr_get("keygen.userid.cmd", fail?
2673                   _("Change (N)ame, (E)mail, or (Q)uit? ") :
2674                   _("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
2675                 cpr_kill_prompt();
2676             }
2677             if( strlen(answer) > 1 )
2678                 ;
2679             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2680                 xfree(aname); aname = NULL;
2681                 break;
2682             }
2683             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2684                 xfree(acomment); acomment = NULL;
2685                 break;
2686             }
2687             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2688                 xfree(amail); amail = NULL;
2689                 break;
2690             }
2691             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2692                 if( fail ) {
2693                     tty_printf(_("Please correct the error first\n"));
2694                 }
2695                 else {
2696                     xfree(aname); aname = NULL;
2697                     xfree(acomment); acomment = NULL;
2698                     xfree(amail); amail = NULL;
2699                     break;
2700                 }
2701             }
2702             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2703                 xfree(aname); aname = NULL;
2704                 xfree(acomment); acomment = NULL;
2705                 xfree(amail); amail = NULL;
2706                 xfree(uid); uid = NULL;
2707                 break;
2708             }
2709             xfree(answer);
2710         }
2711         xfree(answer);
2712         if (!amail && !acomment)
2713             break;
2714         xfree(uid); uid = NULL;
2715     }
2716     if( uid ) {
2717         char *p = native_to_utf8( uid );
2718         xfree( uid );
2719         uid = p;
2720     }
2721     return uid;
2722 }
2723
2724
2725 /* Basic key generation.  Here we divert to the actual generation
2726    routines based on the requested algorithm.  */
2727 static int
2728 do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
2729            u32 timestamp, u32 expiredate, int is_subkey,
2730            int keygen_flags, const char *passphrase, char **cache_nonce_addr)
2731 {
2732   gpg_error_t err;
2733
2734   /* Fixme: The entropy collecting message should be moved to a
2735      libgcrypt progress handler.  */
2736   if (!opt.batch)
2737     tty_printf (_(
2738 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2739 "some other action (type on the keyboard, move the mouse, utilize the\n"
2740 "disks) during the prime generation; this gives the random number\n"
2741 "generator a better chance to gain enough entropy.\n") );
2742
2743   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2744     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2745                    keygen_flags, passphrase, cache_nonce_addr);
2746   else if (algo == PUBKEY_ALGO_DSA)
2747     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2748                    keygen_flags, passphrase, cache_nonce_addr);
2749   else if (algo == PUBKEY_ALGO_ECDSA
2750            || algo == PUBKEY_ALGO_EDDSA
2751            || algo == PUBKEY_ALGO_ECDH)
2752     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
2753                    keygen_flags, passphrase, cache_nonce_addr);
2754   else if (algo == PUBKEY_ALGO_RSA)
2755     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2756                    keygen_flags, passphrase, cache_nonce_addr);
2757   else
2758     BUG();
2759
2760   return err;
2761 }
2762
2763
2764 /* Generate a new user id packet or return NULL if canceled.  If
2765    KEYBLOCK is not NULL the function prevents the creation of an
2766    already existing user ID.  If UIDSTR is not NULL the user is not
2767    asked but UIDSTR is used to create the user id packet; if the user
2768    id already exists NULL is returned.  UIDSTR is expected to be utf-8
2769    encoded and should have already been checked for a valid length
2770    etc.  */
2771 PKT_user_id *
2772 generate_user_id (KBNODE keyblock, const char *uidstr)
2773 {
2774   PKT_user_id *uid;
2775   char *p;
2776
2777   if (uidstr)
2778     {
2779       if (uid_already_in_keyblock (keyblock, uidstr))
2780         return NULL;  /* Already exists.  */
2781       uid = uid_from_string (uidstr);
2782     }
2783   else
2784     {
2785       p = ask_user_id (1, 1, keyblock);
2786       if (!p)
2787         return NULL;  /* Canceled. */
2788       uid = uid_from_string (p);
2789       xfree (p);
2790     }
2791   return uid;
2792 }
2793
2794
2795 /* Append R to the linked list PARA.  */
2796 static void
2797 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
2798 {
2799   assert (para);
2800   while (para->next)
2801     para = para->next;
2802   para->next = r;
2803 }
2804
2805 /* Release the parameter list R.  */
2806 static void
2807 release_parameter_list (struct para_data_s *r)
2808 {
2809   struct para_data_s *r2;
2810
2811   for (; r ; r = r2)
2812     {
2813       r2 = r->next;
2814       if (r->key == pPASSPHRASE && *r->u.value)
2815         wipememory (r->u.value, strlen (r->u.value));
2816       xfree (r);
2817     }
2818 }
2819
2820 static struct para_data_s *
2821 get_parameter( struct para_data_s *para, enum para_name key )
2822 {
2823     struct para_data_s *r;
2824
2825     for( r = para; r && r->key != key; r = r->next )
2826         ;
2827     return r;
2828 }
2829
2830 static const char *
2831 get_parameter_value( struct para_data_s *para, enum para_name key )
2832 {
2833     struct para_data_s *r = get_parameter( para, key );
2834     return (r && *r->u.value)? r->u.value : NULL;
2835 }
2836
2837
2838 /* This is similar to get_parameter_value but also returns the empty
2839    string.  This is required so that quick_generate_keypair can use an
2840    empty Passphrase to specify no-protection.  */
2841 static const char *
2842 get_parameter_passphrase (struct para_data_s *para)
2843 {
2844   struct para_data_s *r = get_parameter (para, pPASSPHRASE);
2845   return r ? r->u.value : NULL;
2846 }
2847
2848
2849 static int
2850 get_parameter_algo( struct para_data_s *para, enum para_name key,
2851                     int *r_default)
2852 {
2853   int i;
2854   struct para_data_s *r = get_parameter( para, key );
2855
2856   if (r_default)
2857     *r_default = 0;
2858
2859   if (!r)
2860     return -1;
2861
2862   /* Note that we need to handle the ECC algorithms specified as
2863      strings directly because Libgcrypt folds them all to ECC.  */
2864   if (!ascii_strcasecmp (r->u.value, "default"))
2865     {
2866       /* Note: If you change this default algo, remember to change it
2867          also in gpg.c:gpgconf_list.  */
2868       i = DEFAULT_STD_ALGO;
2869       if (r_default)
2870         *r_default = 1;
2871     }
2872   else if (digitp (r->u.value))
2873     i = atoi( r->u.value );
2874   else if (!strcmp (r->u.value, "ELG-E")
2875            || !strcmp (r->u.value, "ELG"))
2876     i = PUBKEY_ALGO_ELGAMAL_E;
2877   else if (!ascii_strcasecmp (r->u.value, "EdDSA"))
2878     i = PUBKEY_ALGO_EDDSA;
2879   else if (!ascii_strcasecmp (r->u.value, "ECDSA"))
2880     i = PUBKEY_ALGO_ECDSA;
2881   else if (!ascii_strcasecmp (r->u.value, "ECDH"))
2882     i = PUBKEY_ALGO_ECDH;
2883   else
2884     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
2885
2886   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2887     i = 0; /* we don't want to allow generation of these algorithms */
2888   return i;
2889 }
2890
2891 /*
2892  * Parse the usage parameter and set the keyflags.  Returns -1 on
2893  * error, 0 for no usage given or 1 for usage available.
2894  */
2895 static int
2896 parse_parameter_usage (const char *fname,
2897                        struct para_data_s *para, enum para_name key)
2898 {
2899     struct para_data_s *r = get_parameter( para, key );
2900     char *p, *pn;
2901     unsigned int use;
2902
2903     if( !r )
2904         return 0; /* none (this is an optional parameter)*/
2905
2906     use = 0;
2907     pn = r->u.value;
2908     while ( (p = strsep (&pn, " \t,")) ) {
2909         if ( !*p)
2910             ;
2911         else if ( !ascii_strcasecmp (p, "sign") )
2912             use |= PUBKEY_USAGE_SIG;
2913         else if ( !ascii_strcasecmp (p, "encrypt") )
2914             use |= PUBKEY_USAGE_ENC;
2915         else if ( !ascii_strcasecmp (p, "auth") )
2916             use |= PUBKEY_USAGE_AUTH;
2917         else {
2918             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2919             return -1; /* error */
2920         }
2921     }
2922     r->u.usage = use;
2923     return 1;
2924 }
2925
2926 static int
2927 parse_revocation_key (const char *fname,
2928                       struct para_data_s *para, enum para_name key)
2929 {
2930   struct para_data_s *r = get_parameter( para, key );
2931   struct revocation_key revkey;
2932   char *pn;
2933   int i;
2934
2935   if( !r )
2936     return 0; /* none (this is an optional parameter) */
2937
2938   pn = r->u.value;
2939
2940   revkey.class=0x80;
2941   revkey.algid=atoi(pn);
2942   if(!revkey.algid)
2943     goto fail;
2944
2945   /* Skip to the fpr */
2946   while(*pn && *pn!=':')
2947     pn++;
2948
2949   if(*pn!=':')
2950     goto fail;
2951
2952   pn++;
2953
2954   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2955     {
2956       int c=hextobyte(pn);
2957       if(c==-1)
2958         goto fail;
2959
2960       revkey.fpr[i]=c;
2961     }
2962
2963   /* skip to the tag */
2964   while(*pn && *pn!='s' && *pn!='S')
2965     pn++;
2966
2967   if(ascii_strcasecmp(pn,"sensitive")==0)
2968     revkey.class|=0x40;
2969
2970   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2971
2972   return 0;
2973
2974   fail:
2975   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2976   return -1; /* error */
2977 }
2978
2979
2980 static u32
2981 get_parameter_u32( struct para_data_s *para, enum para_name key )
2982 {
2983   struct para_data_s *r = get_parameter( para, key );
2984
2985   if( !r )
2986     return 0;
2987   if( r->key == pKEYCREATIONDATE )
2988     return r->u.creation;
2989   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2990     return r->u.expire;
2991   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2992     return r->u.usage;
2993
2994   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2995 }
2996
2997 static unsigned int
2998 get_parameter_uint( struct para_data_s *para, enum para_name key )
2999 {
3000     return get_parameter_u32( para, key );
3001 }
3002
3003 static struct revocation_key *
3004 get_parameter_revkey( struct para_data_s *para, enum para_name key )
3005 {
3006     struct para_data_s *r = get_parameter( para, key );
3007     return r? &r->u.revkey : NULL;
3008 }
3009
3010 static int
3011 proc_parameter_file (ctrl_t ctrl, struct para_data_s *para, const char *fname,
3012                      struct output_control_s *outctrl, int card )
3013 {
3014   struct para_data_s *r;
3015   const char *s1, *s2, *s3;
3016   size_t n;
3017   char *p;
3018   int is_default = 0;
3019   int have_user_id = 0;
3020   int err, algo;
3021
3022   /* Check that we have all required parameters. */
3023   r = get_parameter( para, pKEYTYPE );
3024   if(r)
3025     {
3026       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
3027       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
3028         {
3029           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3030           return -1;
3031         }
3032     }
3033   else
3034     {
3035       log_error ("%s: no Key-Type specified\n",fname);
3036       return -1;
3037     }
3038
3039   err = parse_parameter_usage (fname, para, pKEYUSAGE);
3040   if (!err)
3041     {
3042       /* Default to algo capabilities if key-usage is not provided and
3043          no default algorithm has been requested.  */
3044       r = xmalloc_clear(sizeof(*r));
3045       r->key = pKEYUSAGE;
3046       r->u.usage = (is_default
3047                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
3048                     : openpgp_pk_algo_usage(algo));
3049       append_to_parameter (para, r);
3050     }
3051   else if (err == -1)
3052     return -1;
3053   else
3054     {
3055       r = get_parameter (para, pKEYUSAGE);
3056       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3057         {
3058           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
3059                      fname, r->lnr, algo);
3060           return -1;
3061         }
3062     }
3063
3064   is_default = 0;
3065   r = get_parameter( para, pSUBKEYTYPE );
3066   if(r)
3067     {
3068       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
3069       if (openpgp_pk_test_algo (algo))
3070         {
3071           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3072           return -1;
3073         }
3074
3075       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
3076       if (!err)
3077         {
3078           /* Default to algo capabilities if subkey-usage is not
3079              provided */
3080           r = xmalloc_clear (sizeof(*r));
3081           r->key = pSUBKEYUSAGE;
3082           r->u.usage = (is_default
3083                         ? PUBKEY_USAGE_ENC
3084                         : openpgp_pk_algo_usage (algo));
3085           append_to_parameter (para, r);
3086         }
3087       else if (err == -1)
3088         return -1;
3089       else
3090         {
3091           r = get_parameter (para, pSUBKEYUSAGE);
3092           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3093             {
3094               log_error ("%s:%d: specified Subkey-Usage not allowed"
3095                          " for algo %d\n", fname, r->lnr, algo);
3096               return -1;
3097             }
3098         }
3099     }
3100
3101
3102   if( get_parameter_value( para, pUSERID ) )
3103     have_user_id=1;
3104   else
3105     {
3106       /* create the formatted user ID */
3107       s1 = get_parameter_value( para, pNAMEREAL );
3108       s2 = get_parameter_value( para, pNAMECOMMENT );
3109       s3 = get_parameter_value( para, pNAMEEMAIL );
3110       if( s1 || s2 || s3 )
3111         {
3112           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
3113           r = xmalloc_clear( sizeof *r + n + 20 );
3114           r->key = pUSERID;
3115           p = r->u.value;
3116           if( s1 )
3117             p = stpcpy(p, s1 );
3118           if( s2 )
3119             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
3120           if( s3 )
3121             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
3122           append_to_parameter (para, r);
3123           have_user_id=1;
3124         }
3125     }
3126
3127   if(!have_user_id)
3128     {
3129       log_error("%s: no User-ID specified\n",fname);
3130       return -1;
3131     }
3132
3133   /* Set preferences, if any. */
3134   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
3135
3136   /* Set keyserver, if any. */
3137   s1=get_parameter_value( para, pKEYSERVER );
3138   if(s1)
3139     {
3140       struct keyserver_spec *spec;
3141
3142       spec = parse_keyserver_uri (s1, 1);
3143       if(spec)
3144         {
3145           free_keyserver_spec(spec);
3146           opt.def_keyserver_url=s1;
3147         }
3148       else
3149         {
3150           r = get_parameter (para, pKEYSERVER);
3151           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
3152           return -1;
3153         }
3154     }
3155
3156   /* Set revoker, if any. */
3157   if (parse_revocation_key (fname, para, pREVOKER))
3158     return -1;
3159
3160
3161   /* Make KEYCREATIONDATE from Creation-Date.  */
3162   r = get_parameter (para, pCREATIONDATE);
3163   if (r && *r->u.value)
3164     {
3165       u32 seconds;
3166
3167       seconds = parse_creation_string (r->u.value);
3168       if (!seconds)
3169         {
3170           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
3171           return -1;
3172         }
3173       r->u.creation = seconds;
3174       r->key = pKEYCREATIONDATE;  /* Change that entry. */
3175     }
3176
3177   /* Make KEYEXPIRE from Expire-Date.  */
3178   r = get_parameter( para, pEXPIREDATE );
3179   if( r && *r->u.value )
3180     {
3181       u32 seconds;
3182
3183       seconds = parse_expire_string( r->u.value );
3184       if( seconds == (u32)-1 )
3185         {
3186           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
3187           return -1;
3188         }
3189       r->u.expire = seconds;
3190       r->key = pKEYEXPIRE;  /* change hat entry */
3191       /* also set it for the subkey */
3192       r = xmalloc_clear( sizeof *r + 20 );
3193       r->key = pSUBKEYEXPIRE;
3194       r->u.expire = seconds;
3195       append_to_parameter (para, r);
3196     }
3197
3198   do_generate_keypair (ctrl, para, outctrl, card );
3199   return 0;
3200 }
3201
3202
3203 /****************
3204  * Kludge to allow non interactive key generation controlled
3205  * by a parameter file.
3206  * Note, that string parameters are expected to be in UTF-8
3207  */
3208 static void
3209 read_parameter_file (ctrl_t ctrl, const char *fname )
3210 {
3211     static struct { const char *name;
3212                     enum para_name key;
3213     } keywords[] = {
3214         { "Key-Type",       pKEYTYPE},
3215         { "Key-Length",     pKEYLENGTH },
3216         { "Key-Curve",      pKEYCURVE },
3217         { "Key-Usage",      pKEYUSAGE },
3218         { "Subkey-Type",    pSUBKEYTYPE },
3219         { "Subkey-Length",  pSUBKEYLENGTH },
3220         { "Subkey-Curve",   pSUBKEYCURVE },
3221         { "Subkey-Usage",   pSUBKEYUSAGE },
3222         { "Name-Real",      pNAMEREAL },
3223         { "Name-Email",     pNAMEEMAIL },
3224         { "Name-Comment",   pNAMECOMMENT },
3225         { "Expire-Date",    pEXPIREDATE },
3226         { "Creation-Date",  pCREATIONDATE },
3227         { "Passphrase",     pPASSPHRASE },
3228         { "Preferences",    pPREFERENCES },
3229         { "Revoker",        pREVOKER },
3230         { "Handle",         pHANDLE },
3231         { "Keyserver",      pKEYSERVER },
3232         { NULL, 0 }
3233     };
3234     IOBUF fp;
3235     byte *line;
3236     unsigned int maxlen, nline;
3237     char *p;
3238     int lnr;
3239     const char *err = NULL;
3240     struct para_data_s *para, *r;
3241     int i;
3242     struct output_control_s outctrl;
3243
3244     memset( &outctrl, 0, sizeof( outctrl ) );
3245     outctrl.pub.afx = new_armor_context ();
3246
3247     if( !fname || !*fname)
3248       fname = "-";
3249
3250     fp = iobuf_open (fname);
3251     if (fp && is_secured_file (iobuf_get_fd (fp)))
3252       {
3253         iobuf_close (fp);
3254         fp = NULL;
3255         gpg_err_set_errno (EPERM);
3256       }
3257     if (!fp) {
3258       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
3259       return;
3260     }
3261     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
3262
3263     lnr = 0;
3264     err = NULL;
3265     para = NULL;
3266     maxlen = 1024;
3267     line = NULL;
3268     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
3269         char *keyword, *value;
3270
3271         lnr++;
3272         if( !maxlen ) {
3273             err = "line too long";
3274             break;
3275         }
3276         for( p = line; isspace(*(byte*)p); p++ )
3277             ;
3278         if( !*p || *p == '#' )
3279             continue;
3280         keyword = p;
3281         if( *keyword == '%' ) {
3282             for( ; !isspace(*(byte*)p); p++ )
3283                 ;
3284             if( *p )
3285                 *p++ = 0;
3286             for( ; isspace(*(byte*)p); p++ )
3287                 ;
3288             value = p;
3289             trim_trailing_ws( value, strlen(value) );
3290             if( !ascii_strcasecmp( keyword, "%echo" ) )
3291                 log_info("%s\n", value );
3292             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
3293                 outctrl.dryrun = 1;
3294             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
3295               ; /* Dummy for backward compatibility. */
3296             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
3297               ; /* Dummy for backward compatibility. */
3298             else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
3299                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
3300             else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
3301                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
3302             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
3303                 outctrl.lnr = lnr;
3304                 if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3305                   print_status_key_not_created
3306                     (get_parameter_value (para, pHANDLE));
3307                 release_parameter_list( para );
3308                 para = NULL;
3309             }
3310             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
3311                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
3312                     ; /* still the same file - ignore it */
3313                 else {
3314                     xfree( outctrl.pub.newfname );
3315                     outctrl.pub.newfname = xstrdup( value );
3316                     outctrl.use_files = 1;
3317                 }
3318             }
3319             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
3320               /* Ignore this command.  */
3321             }
3322             else
3323                 log_info("skipping control '%s' (%s)\n", keyword, value );
3324
3325
3326             continue;
3327         }
3328
3329
3330         if( !(p = strchr( p, ':' )) || p == keyword ) {
3331             err = "missing colon";
3332             break;
3333         }
3334         if( *p )
3335             *p++ = 0;
3336         for( ; isspace(*(byte*)p); p++ )
3337             ;
3338         if( !*p ) {
3339             err = "missing argument";
3340             break;
3341         }
3342         value = p;
3343         trim_trailing_ws( value, strlen(value) );
3344
3345         for(i=0; keywords[i].name; i++ ) {
3346             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
3347                 break;
3348         }
3349         if( !keywords[i].name ) {
3350             err = "unknown keyword";
3351             break;
3352         }
3353         if( keywords[i].key != pKEYTYPE && !para ) {
3354             err = "parameter block does not start with \"Key-Type\"";
3355             break;
3356         }
3357
3358         if( keywords[i].key == pKEYTYPE && para ) {
3359             outctrl.lnr = lnr;
3360             if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3361               print_status_key_not_created
3362                 (get_parameter_value (para, pHANDLE));
3363             release_parameter_list( para );
3364             para = NULL;
3365         }
3366         else {
3367             for( r = para; r; r = r->next ) {
3368                 if( r->key == keywords[i].key )
3369                     break;
3370             }
3371             if( r ) {
3372                 err = "duplicate keyword";
3373                 break;
3374             }
3375         }
3376         r = xmalloc_clear( sizeof *r + strlen( value ) );
3377         r->lnr = lnr;
3378         r->key = keywords[i].key;
3379         strcpy( r->u.value, value );
3380         r->next = para;
3381         para = r;
3382     }
3383     if( err )
3384         log_error("%s:%d: %s\n", fname, lnr, err );
3385     else if( iobuf_error (fp) ) {
3386         log_error("%s:%d: read error\n", fname, lnr);
3387     }
3388     else if( para ) {
3389         outctrl.lnr = lnr;
3390         if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3391           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3392     }
3393
3394     if( outctrl.use_files ) { /* close open streams */
3395         iobuf_close( outctrl.pub.stream );
3396
3397         /* Must invalidate that ugly cache to actually close it.  */
3398         if (outctrl.pub.fname)
3399           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3400                        0, (char*)outctrl.pub.fname);
3401
3402         xfree( outctrl.pub.fname );
3403         xfree( outctrl.pub.newfname );
3404     }
3405
3406     release_parameter_list( para );
3407     iobuf_close (fp);
3408     release_armor_context (outctrl.pub.afx);
3409 }
3410
3411
3412 /* Helper for quick_generate_keypair.  */
3413 static struct para_data_s *
3414 quickgen_set_para (struct para_data_s *para, int for_subkey,
3415                    int algo, int nbits, const char *curve)
3416 {
3417   struct para_data_s *r;
3418
3419   r = xmalloc_clear (sizeof *r + 20);
3420   r->key = for_subkey? pSUBKEYUSAGE :  pKEYUSAGE;
3421   strcpy (r->u.value, for_subkey ? "encrypt" : "sign");
3422   r->next = para;
3423   para = r;
3424   r = xmalloc_clear (sizeof *r + 20);
3425   r->key = for_subkey? pSUBKEYTYPE : pKEYTYPE;
3426   snprintf (r->u.value, 20, "%d", algo);
3427   r->next = para;
3428   para = r;
3429
3430   if (curve)
3431     {
3432       r = xmalloc_clear (sizeof *r + strlen (curve));
3433       r->key = for_subkey? pSUBKEYCURVE : pKEYCURVE;
3434       strcpy (r->u.value, curve);
3435       r->next = para;
3436       para = r;
3437     }
3438   else
3439     {
3440       r = xmalloc_clear (sizeof *r + 20);
3441       r->key = for_subkey? pSUBKEYLENGTH : pKEYLENGTH;
3442       sprintf (r->u.value, "%u", nbits);
3443       r->next = para;
3444       para = r;
3445     }
3446
3447   return para;
3448 }
3449
3450
3451 /*
3452  * Unattended generation of a standard key.
3453  */
3454 void
3455 quick_generate_keypair (ctrl_t ctrl, const char *uid)
3456 {
3457   gpg_error_t err;
3458   struct para_data_s *para = NULL;
3459   struct para_data_s *r;
3460   struct output_control_s outctrl;
3461   int use_tty;
3462
3463   memset (&outctrl, 0, sizeof outctrl);
3464
3465   use_tty = (!opt.batch && !opt.answer_yes
3466              && !cpr_enabled ()
3467              && gnupg_isatty (fileno (stdin))
3468              && gnupg_isatty (fileno (stdout))
3469              && gnupg_isatty (fileno (stderr)));
3470
3471   r = xmalloc_clear (sizeof *r + strlen (uid));
3472   r->key = pUSERID;
3473   strcpy (r->u.value, uid);
3474   r->next = para;
3475   para = r;
3476
3477   uid = trim_spaces (r->u.value);
3478   if (!*uid || (!opt.allow_freeform_uid && !is_valid_user_id (uid)))
3479     {
3480       log_error (_("Key generation failed: %s\n"),
3481                  gpg_strerror (GPG_ERR_INV_USER_ID));
3482       goto leave;
3483     }
3484
3485   /* If gpg is directly used on the console ask whether a key with the
3486      given user id shall really be created.  */
3487   if (use_tty)
3488     {
3489       tty_printf (_("About to create a key for:\n    \"%s\"\n\n"), uid);
3490       if (!cpr_get_answer_is_yes_def ("quick_keygen.okay",
3491                                       _("Continue? (Y/n) "), 1))
3492         goto leave;
3493     }
3494
3495   /* Check whether such a user ID already exists.  */
3496   {
3497     KEYDB_HANDLE kdbhd;
3498     KEYDB_SEARCH_DESC desc;
3499
3500     memset (&desc, 0, sizeof desc);
3501     desc.mode = KEYDB_SEARCH_MODE_EXACT;
3502     desc.u.name = uid;
3503
3504     kdbhd = keydb_new ();
3505     if (!kdbhd)
3506       goto leave;
3507
3508     err = keydb_search (kdbhd, &desc, 1, NULL);
3509     keydb_release (kdbhd);
3510     if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
3511       {
3512         log_info (_("A key for \"%s\" already exists\n"), uid);
3513         if (opt.answer_yes)
3514           ;
3515         else if (!use_tty
3516                  || !cpr_get_answer_is_yes_def ("quick_keygen.force",
3517                                                 _("Create anyway? (y/N) "), 0))
3518           {
3519             log_inc_errorcount ();  /* we used log_info */
3520             goto leave;
3521           }
3522         log_info (_("creating anyway\n"));
3523       }
3524   }
3525
3526   para = quickgen_set_para (para, 0,
3527                             DEFAULT_STD_ALGO, DEFAULT_STD_KEYSIZE,
3528                             DEFAULT_STD_CURVE);
3529   para = quickgen_set_para (para, 1,
3530                             DEFAULT_STD_SUBALGO, DEFAULT_STD_SUBKEYSIZE,
3531                             DEFAULT_STD_SUBCURVE);
3532
3533   /* If the pinentry loopback mode is not and we have a static
3534      passphrase (i.e. set with --passphrase{,-fd,-file} while in batch
3535      mode), we use that passphrase for the new key.  */
3536   if (opt.pinentry_mode != PINENTRY_MODE_LOOPBACK
3537       && have_static_passphrase ())
3538     {
3539       const char *s = get_static_passphrase ();
3540
3541       r = xmalloc_clear (sizeof *r + strlen (s));
3542       r->key = pPASSPHRASE;
3543       strcpy (r->u.value, s);
3544       r->next = para;
3545       para = r;
3546     }
3547
3548   proc_parameter_file (ctrl, para, "[internal]", &outctrl, 0);
3549  leave:
3550   release_parameter_list (para);
3551 }
3552
3553
3554 /*
3555  * Generate a keypair (fname is only used in batch mode) If
3556  * CARD_SERIALNO is not NULL the function will create the keys on an
3557  * OpenPGP Card.  If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
3558  * NOT NULL, the encryption key for the card is generated on the host,
3559  * imported to the card and a backup file created by gpg-agent.  If
3560  * FULL is not set only the basic prompts are used (except for batch
3561  * mode).
3562  */
3563 void
3564 generate_keypair (ctrl_t ctrl, int full, const char *fname,
3565                   const char *card_serialno, int card_backup_key)
3566 {
3567   unsigned int nbits;
3568   char *uid = NULL;
3569   int algo;
3570   unsigned int use;
3571   int both = 0;
3572   u32 expire;
3573   struct para_data_s *para = NULL;
3574   struct para_data_s *r;
3575   struct output_control_s outctrl;
3576
3577 #ifndef ENABLE_CARD_SUPPORT
3578   (void)card_backup_key;
3579 #endif
3580
3581   memset( &outctrl, 0, sizeof( outctrl ) );
3582
3583   if (opt.batch && card_serialno)
3584     {
3585       /* We don't yet support unattended key generation. */
3586       log_error (_("can't do this in batch mode\n"));
3587       return;
3588     }
3589
3590   if (opt.batch)
3591     {
3592       read_parameter_file (ctrl, fname);
3593       return;
3594     }
3595
3596   if (card_serialno)
3597     {
3598 #ifdef ENABLE_CARD_SUPPORT
3599       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3600       r->key = pSERIALNO;
3601       strcpy( r->u.value, card_serialno);
3602       r->next = para;
3603       para = r;
3604
3605       algo = PUBKEY_ALGO_RSA;
3606
3607       r = xcalloc (1, sizeof *r + 20 );
3608       r->key = pKEYTYPE;
3609       sprintf( r->u.value, "%d", algo );
3610       r->next = para;
3611       para = r;
3612       r = xcalloc (1, sizeof *r + 20 );
3613       r->key = pKEYUSAGE;
3614       strcpy (r->u.value, "sign");
3615       r->next = para;
3616       para = r;
3617
3618       r = xcalloc (1, sizeof *r + 20 );
3619       r->key = pSUBKEYTYPE;
3620       sprintf( r->u.value, "%d", algo );
3621       r->next = para;
3622       para = r;
3623       r = xcalloc (1, sizeof *r + 20 );
3624       r->key = pSUBKEYUSAGE;
3625       strcpy (r->u.value, "encrypt");
3626       r->next = para;
3627       para = r;
3628
3629       r = xcalloc (1, sizeof *r + 20 );
3630       r->key = pAUTHKEYTYPE;
3631       sprintf( r->u.value, "%d", algo );
3632       r->next = para;
3633       para = r;
3634
3635       if (card_backup_key)
3636         {
3637           r = xcalloc (1, sizeof *r + 1);
3638           r->key = pCARDBACKUPKEY;
3639           strcpy (r->u.value, "1");
3640           r->next = para;
3641           para = r;
3642         }
3643 #endif /*ENABLE_CARD_SUPPORT*/
3644     }
3645   else if (full)  /* Full featured key generation.  */
3646     {
3647       int subkey_algo;
3648       char *curve = NULL;
3649
3650       /* Fixme: To support creating a primary key by keygrip we better
3651          also define the keyword for the parameter file.  Note that
3652          the subkey case will never be asserted if a keygrip has been
3653          given.  */
3654       algo = ask_algo (ctrl, 0, &subkey_algo, &use, NULL);
3655       if (subkey_algo)
3656         {
3657           /* Create primary and subkey at once.  */
3658           both = 1;
3659           if (algo == PUBKEY_ALGO_ECDSA
3660               || algo == PUBKEY_ALGO_EDDSA
3661               || algo == PUBKEY_ALGO_ECDH)
3662             {
3663               curve = ask_curve (&algo, &subkey_algo);
3664               r = xmalloc_clear( sizeof *r + 20 );
3665               r->key = pKEYTYPE;
3666               sprintf( r->u.value, "%d", algo);