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