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