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