gpg: In search-keys return "Not found" instead of "No Data".
[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 compression.  */
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   log_assert (revkey->fprlen <= MAX_FINGERPRINT_LEN);
947   buf[0] = revkey->class;
948   buf[1] = revkey->algid;
949   memcpy (buf + 2, revkey->fpr, revkey->fprlen);
950   memset (buf + 2 + revkey->fprlen, 0, sizeof (revkey->fpr) - revkey->fprlen);
951
952   build_sig_subpkt (sig, SIGSUBPKT_REV_KEY, buf, 2+revkey->fprlen);
953
954   /* All sigs with revocation keys set are nonrevocable.  */
955   sig->flags.revocable = 0;
956   buf[0] = 0;
957   build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
958
959   parse_revkeys (sig);
960
961   return 0;
962 }
963
964
965
966 /* Create a back-signature.  If TIMESTAMP is not NULL, use it for the
967    signature creation time.  */
968 gpg_error_t
969 make_backsig (ctrl_t ctrl, PKT_signature *sig, PKT_public_key *pk,
970               PKT_public_key *sub_pk, PKT_public_key *sub_psk,
971               u32 timestamp, const char *cache_nonce)
972 {
973   gpg_error_t err;
974   PKT_signature *backsig;
975
976   cache_public_key (sub_pk);
977
978   err = make_keysig_packet (ctrl, &backsig, pk, NULL, sub_pk, sub_psk, 0x19,
979                             0, timestamp, 0, NULL, NULL, cache_nonce);
980   if (err)
981     log_error ("make_keysig_packet failed for backsig: %s\n",
982                gpg_strerror (err));
983   else
984     {
985       /* Get it into a binary packed form. */
986       IOBUF backsig_out = iobuf_temp();
987       PACKET backsig_pkt;
988
989       init_packet (&backsig_pkt);
990       backsig_pkt.pkttype = PKT_SIGNATURE;
991       backsig_pkt.pkt.signature = backsig;
992       err = build_packet (backsig_out, &backsig_pkt);
993       free_packet (&backsig_pkt, NULL);
994       if (err)
995         log_error ("build_packet failed for backsig: %s\n", gpg_strerror (err));
996       else
997         {
998           size_t pktlen = 0;
999           byte *buf = iobuf_get_temp_buffer (backsig_out);
1000
1001           /* Remove the packet header. */
1002           if(buf[0]&0x40)
1003             {
1004               if (buf[1] < 192)
1005                 {
1006                   pktlen = buf[1];
1007                   buf += 2;
1008                 }
1009               else if(buf[1] < 224)
1010                 {
1011                   pktlen = (buf[1]-192)*256;
1012                   pktlen += buf[2]+192;
1013                   buf += 3;
1014                 }
1015               else if (buf[1] == 255)
1016                 {
1017                   pktlen = buf32_to_size_t (buf+2);
1018                   buf += 6;
1019                 }
1020               else
1021                 BUG ();
1022             }
1023           else
1024             {
1025               int mark = 1;
1026
1027               switch (buf[0]&3)
1028                 {
1029                 case 3:
1030                   BUG ();
1031                   break;
1032
1033                 case 2:
1034                   pktlen  = (size_t)buf[mark++] << 24;
1035                   pktlen |= buf[mark++] << 16;
1036                   /* fall through */
1037                 case 1:
1038                   pktlen |= buf[mark++] << 8;
1039                   /* fall through */
1040                 case 0:
1041                   pktlen |= buf[mark++];
1042                 }
1043
1044               buf += mark;
1045             }
1046
1047           /* Now make the binary blob into a subpacket.  */
1048           build_sig_subpkt (sig, SIGSUBPKT_SIGNATURE, buf, pktlen);
1049
1050           iobuf_close (backsig_out);
1051         }
1052     }
1053
1054   return err;
1055 }
1056
1057
1058 /* Write a direct key signature to the first key in ROOT using the key
1059    PSK.  REVKEY is describes the direct key signature and TIMESTAMP is
1060    the timestamp to set on the signature.  */
1061 static gpg_error_t
1062 write_direct_sig (ctrl_t ctrl, kbnode_t root, PKT_public_key *psk,
1063                   struct revocation_key *revkey, u32 timestamp,
1064                   const char *cache_nonce)
1065 {
1066   gpg_error_t err;
1067   PACKET *pkt;
1068   PKT_signature *sig;
1069   KBNODE node;
1070   PKT_public_key *pk;
1071
1072   if (opt.verbose)
1073     log_info (_("writing direct signature\n"));
1074
1075   /* Get the pk packet from the pub_tree. */
1076   node = find_kbnode (root, PKT_PUBLIC_KEY);
1077   if (!node)
1078     BUG ();
1079   pk = node->pkt->pkt.public_key;
1080
1081   /* We have to cache the key, so that the verification of the
1082      signature creation is able to retrieve the public key.  */
1083   cache_public_key (pk);
1084
1085   /* Make the signature.  */
1086   err = make_keysig_packet (ctrl, &sig, pk, NULL,NULL, psk, 0x1F,
1087                             0, timestamp, 0,
1088                             keygen_add_revkey, revkey, cache_nonce);
1089   if (err)
1090     {
1091       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err) );
1092       return err;
1093     }
1094
1095   pkt = xmalloc_clear (sizeof *pkt);
1096   pkt->pkttype = PKT_SIGNATURE;
1097   pkt->pkt.signature = sig;
1098   add_kbnode (root, new_kbnode (pkt));
1099   return err;
1100 }
1101
1102
1103
1104 /* Write a self-signature to the first user id in ROOT using the key
1105    PSK.  USE and TIMESTAMP give the extra data we need for the
1106    signature.  */
1107 static gpg_error_t
1108 write_selfsigs (ctrl_t ctrl, kbnode_t root, PKT_public_key *psk,
1109                 unsigned int use, u32 timestamp, const char *cache_nonce)
1110 {
1111   gpg_error_t err;
1112   PACKET *pkt;
1113   PKT_signature *sig;
1114   PKT_user_id *uid;
1115   KBNODE node;
1116   PKT_public_key *pk;
1117
1118   if (opt.verbose)
1119     log_info (_("writing self signature\n"));
1120
1121   /* Get the uid packet from the list. */
1122   node = find_kbnode (root, PKT_USER_ID);
1123   if (!node)
1124     BUG(); /* No user id packet in tree.  */
1125   uid = node->pkt->pkt.user_id;
1126
1127   /* Get the pk packet from the pub_tree. */
1128   node = find_kbnode (root, PKT_PUBLIC_KEY);
1129   if (!node)
1130     BUG();
1131   pk = node->pkt->pkt.public_key;
1132
1133   /* The usage has not yet been set - do it now. */
1134   pk->pubkey_usage = use;
1135
1136   /* We have to cache the key, so that the verification of the
1137      signature creation is able to retrieve the public key.  */
1138   cache_public_key (pk);
1139
1140   /* Make the signature.  */
1141   err = make_keysig_packet (ctrl, &sig, pk, uid, NULL, psk, 0x13,
1142                             0, timestamp, 0,
1143                             keygen_add_std_prefs, pk, cache_nonce);
1144   if (err)
1145     {
1146       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err));
1147       return err;
1148     }
1149
1150   pkt = xmalloc_clear (sizeof *pkt);
1151   pkt->pkttype = PKT_SIGNATURE;
1152   pkt->pkt.signature = sig;
1153   add_kbnode (root, new_kbnode (pkt));
1154
1155   return err;
1156 }
1157
1158
1159 /* Write the key binding signature.  If TIMESTAMP is not NULL use the
1160    signature creation time.  PRI_PSK is the key use for signing.
1161    SUB_PSK is a key used to create a back-signature; that one is only
1162    used if USE has the PUBKEY_USAGE_SIG capability.  */
1163 static int
1164 write_keybinding (ctrl_t ctrl, kbnode_t root,
1165                   PKT_public_key *pri_psk, PKT_public_key *sub_psk,
1166                   unsigned int use, u32 timestamp, const char *cache_nonce)
1167 {
1168   gpg_error_t err;
1169   PACKET *pkt;
1170   PKT_signature *sig;
1171   KBNODE node;
1172   PKT_public_key *pri_pk, *sub_pk;
1173   struct opaque_data_usage_and_pk oduap;
1174
1175   if (opt.verbose)
1176     log_info(_("writing key binding signature\n"));
1177
1178   /* Get the primary pk packet from the tree.  */
1179   node = find_kbnode (root, PKT_PUBLIC_KEY);
1180   if (!node)
1181     BUG();
1182   pri_pk = node->pkt->pkt.public_key;
1183
1184   /* We have to cache the key, so that the verification of the
1185    * signature creation is able to retrieve the public key.  */
1186   cache_public_key (pri_pk);
1187
1188   /* Find the last subkey. */
1189   sub_pk = NULL;
1190   for (node = root; node; node = node->next )
1191     {
1192       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1193         sub_pk = node->pkt->pkt.public_key;
1194     }
1195   if (!sub_pk)
1196     BUG();
1197
1198   /* Make the signature.  */
1199   oduap.usage = use;
1200   oduap.pk = sub_pk;
1201   err = make_keysig_packet (ctrl, &sig, pri_pk, NULL, sub_pk, pri_psk, 0x18,
1202                             0, timestamp, 0,
1203                             keygen_add_key_flags_and_expire, &oduap,
1204                             cache_nonce);
1205   if (err)
1206     {
1207       log_error ("make_keysig_packeto failed: %s\n", gpg_strerror (err));
1208       return err;
1209     }
1210
1211   /* Make a backsig.  */
1212   if (use & PUBKEY_USAGE_SIG)
1213     {
1214       err = make_backsig (ctrl,
1215                           sig, pri_pk, sub_pk, sub_psk, timestamp, cache_nonce);
1216       if (err)
1217         return err;
1218     }
1219
1220   pkt = xmalloc_clear ( sizeof *pkt );
1221   pkt->pkttype = PKT_SIGNATURE;
1222   pkt->pkt.signature = sig;
1223   add_kbnode (root, new_kbnode (pkt) );
1224   return err;
1225 }
1226
1227
1228 static gpg_error_t
1229 ecckey_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp, int algo)
1230 {
1231   gpg_error_t err;
1232   gcry_sexp_t list, l2;
1233   char *curve = NULL;
1234   int i;
1235   const char *oidstr;
1236   unsigned int nbits;
1237
1238   array[0] = NULL;
1239   array[1] = NULL;
1240   array[2] = NULL;
1241
1242   list = gcry_sexp_find_token (sexp, "public-key", 0);
1243   if (!list)
1244     return gpg_error (GPG_ERR_INV_OBJ);
1245   l2 = gcry_sexp_cadr (list);
1246   gcry_sexp_release (list);
1247   list = l2;
1248   if (!list)
1249     return gpg_error (GPG_ERR_NO_OBJ);
1250
1251   l2 = gcry_sexp_find_token (list, "curve", 0);
1252   if (!l2)
1253     {
1254       err = gpg_error (GPG_ERR_NO_OBJ);
1255       goto leave;
1256     }
1257   curve = gcry_sexp_nth_string (l2, 1);
1258   if (!curve)
1259     {
1260       err = gpg_error (GPG_ERR_NO_OBJ);
1261       goto leave;
1262     }
1263   gcry_sexp_release (l2);
1264   oidstr = openpgp_curve_to_oid (curve, &nbits);
1265   if (!oidstr)
1266     {
1267       /* That can't happen because we used one of the curves
1268          gpg_curve_to_oid knows about.  */
1269       err = gpg_error (GPG_ERR_INV_OBJ);
1270       goto leave;
1271     }
1272   err = openpgp_oid_from_str (oidstr, &array[0]);
1273   if (err)
1274     goto leave;
1275
1276   l2 = gcry_sexp_find_token (list, "q", 0);
1277   if (!l2)
1278     {
1279       err = gpg_error (GPG_ERR_NO_OBJ);
1280       goto leave;
1281     }
1282   array[1] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1283   gcry_sexp_release (l2);
1284   if (!array[1])
1285     {
1286       err = gpg_error (GPG_ERR_INV_OBJ);
1287       goto leave;
1288     }
1289   gcry_sexp_release (list);
1290
1291   if (algo == PUBKEY_ALGO_ECDH)
1292     {
1293       array[2] = pk_ecdh_default_params (nbits);
1294       if (!array[2])
1295         {
1296           err = gpg_error_from_syserror ();
1297           goto leave;
1298         }
1299     }
1300
1301  leave:
1302   xfree (curve);
1303   if (err)
1304     {
1305       for (i=0; i < 3; i++)
1306         {
1307           gcry_mpi_release (array[i]);
1308           array[i] = NULL;
1309         }
1310     }
1311   return err;
1312 }
1313
1314
1315 /* Extract key parameters from SEXP and store them in ARRAY.  ELEMS is
1316    a string where each character denotes a parameter name.  TOPNAME is
1317    the name of the top element above the elements.  */
1318 static int
1319 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
1320                const char *topname, const char *elems)
1321 {
1322   gcry_sexp_t list, l2;
1323   const char *s;
1324   int i, idx;
1325   int rc = 0;
1326
1327   list = gcry_sexp_find_token (sexp, topname, 0);
1328   if (!list)
1329     return gpg_error (GPG_ERR_INV_OBJ);
1330   l2 = gcry_sexp_cadr (list);
1331   gcry_sexp_release (list);
1332   list = l2;
1333   if (!list)
1334     return gpg_error (GPG_ERR_NO_OBJ);
1335
1336   for (idx=0,s=elems; *s; s++, idx++)
1337     {
1338       l2 = gcry_sexp_find_token (list, s, 1);
1339       if (!l2)
1340         {
1341           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
1342           goto leave;
1343         }
1344       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1345       gcry_sexp_release (l2);
1346       if (!array[idx])
1347         {
1348           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
1349           goto leave;
1350         }
1351     }
1352   gcry_sexp_release (list);
1353
1354  leave:
1355   if (rc)
1356     {
1357       for (i=0; i<idx; i++)
1358         {
1359           gcry_mpi_release (array[i]);
1360           array[i] = NULL;
1361         }
1362       gcry_sexp_release (list);
1363     }
1364   return rc;
1365 }
1366
1367
1368 /* Create a keyblock using the given KEYGRIP.  ALGO is the OpenPGP
1369    algorithm of that keygrip.  */
1370 static int
1371 do_create_from_keygrip (ctrl_t ctrl, int algo, const char *hexkeygrip,
1372                         kbnode_t pub_root, u32 timestamp, u32 expireval,
1373                         int is_subkey)
1374 {
1375   int err;
1376   PACKET *pkt;
1377   PKT_public_key *pk;
1378   gcry_sexp_t s_key;
1379   const char *algoelem;
1380
1381   if (hexkeygrip[0] == '&')
1382     hexkeygrip++;
1383
1384   switch (algo)
1385     {
1386     case PUBKEY_ALGO_RSA:       algoelem = "ne"; break;
1387     case PUBKEY_ALGO_DSA:       algoelem = "pqgy"; break;
1388     case PUBKEY_ALGO_ELGAMAL_E: algoelem = "pgy"; break;
1389     case PUBKEY_ALGO_ECDH:
1390     case PUBKEY_ALGO_ECDSA:     algoelem = ""; break;
1391     case PUBKEY_ALGO_EDDSA:     algoelem = ""; break;
1392     default: return gpg_error (GPG_ERR_INTERNAL);
1393     }
1394
1395
1396   /* Ask the agent for the public key matching HEXKEYGRIP.  */
1397   {
1398     unsigned char *public;
1399
1400     err = agent_readkey (ctrl, 0, hexkeygrip, &public);
1401     if (err)
1402       return err;
1403     err = gcry_sexp_sscan (&s_key, NULL,
1404                            public, gcry_sexp_canon_len (public, 0, NULL, NULL));
1405     xfree (public);
1406     if (err)
1407       return err;
1408   }
1409
1410   /* Build a public key packet.  */
1411   pk = xtrycalloc (1, sizeof *pk);
1412   if (!pk)
1413     {
1414       err = gpg_error_from_syserror ();
1415       gcry_sexp_release (s_key);
1416       return err;
1417     }
1418
1419   pk->timestamp = timestamp;
1420   pk->version = 4;
1421   if (expireval)
1422     pk->expiredate = pk->timestamp + expireval;
1423   pk->pubkey_algo = algo;
1424
1425   if (algo == PUBKEY_ALGO_ECDSA
1426       || algo == PUBKEY_ALGO_EDDSA
1427       || algo == PUBKEY_ALGO_ECDH )
1428     err = ecckey_from_sexp (pk->pkey, s_key, algo);
1429   else
1430     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1431   if (err)
1432     {
1433       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1434       gcry_sexp_release (s_key);
1435       free_public_key (pk);
1436       return err;
1437     }
1438   gcry_sexp_release (s_key);
1439
1440   pkt = xtrycalloc (1, sizeof *pkt);
1441   if (!pkt)
1442     {
1443       err = gpg_error_from_syserror ();
1444       free_public_key (pk);
1445       return err;
1446     }
1447
1448   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1449   pkt->pkt.public_key = pk;
1450   add_kbnode (pub_root, new_kbnode (pkt));
1451
1452   return 0;
1453 }
1454
1455
1456 /* Common code for the key generation function gen_xxx.  */
1457 static int
1458 common_gen (const char *keyparms, int algo, const char *algoelem,
1459             kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
1460             int keygen_flags, const char *passphrase,
1461             char **cache_nonce_addr, char **passwd_nonce_addr)
1462 {
1463   int err;
1464   PACKET *pkt;
1465   PKT_public_key *pk;
1466   gcry_sexp_t s_key;
1467
1468   err = agent_genkey (NULL, cache_nonce_addr, passwd_nonce_addr, keyparms,
1469                       !!(keygen_flags & KEYGEN_FLAG_NO_PROTECTION),
1470                       passphrase,
1471                       &s_key);
1472   if (err)
1473     {
1474       log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
1475       return err;
1476     }
1477
1478   pk = xtrycalloc (1, sizeof *pk);
1479   if (!pk)
1480     {
1481       err = gpg_error_from_syserror ();
1482       gcry_sexp_release (s_key);
1483       return err;
1484     }
1485
1486   pk->timestamp = timestamp;
1487   pk->version = 4;
1488   if (expireval)
1489     pk->expiredate = pk->timestamp + expireval;
1490   pk->pubkey_algo = algo;
1491
1492   if (algo == PUBKEY_ALGO_ECDSA
1493       || algo == PUBKEY_ALGO_EDDSA
1494       || algo == PUBKEY_ALGO_ECDH )
1495     err = ecckey_from_sexp (pk->pkey, s_key, algo);
1496   else
1497     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1498   if (err)
1499     {
1500       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1501       gcry_sexp_release (s_key);
1502       free_public_key (pk);
1503       return err;
1504     }
1505   gcry_sexp_release (s_key);
1506
1507   pkt = xtrycalloc (1, sizeof *pkt);
1508   if (!pkt)
1509     {
1510       err = gpg_error_from_syserror ();
1511       free_public_key (pk);
1512       return err;
1513     }
1514
1515   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1516   pkt->pkt.public_key = pk;
1517   add_kbnode (pub_root, new_kbnode (pkt));
1518
1519   return 0;
1520 }
1521
1522
1523 /*
1524  * Generate an Elgamal key.
1525  */
1526 static int
1527 gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
1528          u32 timestamp, u32 expireval, int is_subkey,
1529          int keygen_flags, const char *passphrase,
1530          char **cache_nonce_addr, char **passwd_nonce_addr)
1531 {
1532   int err;
1533   char *keyparms;
1534   char nbitsstr[35];
1535
1536   log_assert (is_ELGAMAL (algo));
1537
1538   if (nbits < 1024)
1539     {
1540       nbits = 2048;
1541       log_info (_("keysize invalid; using %u bits\n"), nbits );
1542     }
1543   else if (nbits > 4096)
1544     {
1545       nbits = 4096;
1546       log_info (_("keysize invalid; using %u bits\n"), nbits );
1547     }
1548
1549   if ((nbits % 32))
1550     {
1551       nbits = ((nbits + 31) / 32) * 32;
1552       log_info (_("keysize rounded up to %u bits\n"), nbits );
1553     }
1554
1555   /* Note that we use transient-key only if no-protection has also
1556      been enabled.  */
1557   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1558   keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)%s))",
1559                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1560                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
1561                            strlen (nbitsstr), nbitsstr,
1562                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1563                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1564                            "(transient-key)" : "" );
1565   if (!keyparms)
1566     err = gpg_error_from_syserror ();
1567   else
1568     {
1569       err = common_gen (keyparms, algo, "pgy",
1570                         pub_root, timestamp, expireval, is_subkey,
1571                         keygen_flags, passphrase,
1572                         cache_nonce_addr, passwd_nonce_addr);
1573       xfree (keyparms);
1574     }
1575
1576   return err;
1577 }
1578
1579
1580 /*
1581  * Generate an DSA key
1582  */
1583 static gpg_error_t
1584 gen_dsa (unsigned int nbits, KBNODE pub_root,
1585          u32 timestamp, u32 expireval, int is_subkey,
1586          int keygen_flags, const char *passphrase,
1587          char **cache_nonce_addr, char **passwd_nonce_addr)
1588 {
1589   int err;
1590   unsigned int qbits;
1591   char *keyparms;
1592   char nbitsstr[35];
1593   char qbitsstr[35];
1594
1595   if (nbits < 768)
1596     {
1597       nbits = 2048;
1598       log_info(_("keysize invalid; using %u bits\n"), nbits );
1599     }
1600   else if ( nbits > 3072 )
1601     {
1602       nbits = 3072;
1603       log_info(_("keysize invalid; using %u bits\n"), nbits );
1604     }
1605
1606   if( (nbits % 64) )
1607     {
1608       nbits = ((nbits + 63) / 64) * 64;
1609       log_info(_("keysize rounded up to %u bits\n"), nbits );
1610     }
1611
1612   /* To comply with FIPS rules we round up to the next value unless in
1613      expert mode.  */
1614   if (!opt.expert && nbits > 1024 && (nbits % 1024))
1615     {
1616       nbits = ((nbits + 1023) / 1024) * 1024;
1617       log_info(_("keysize rounded up to %u bits\n"), nbits );
1618     }
1619
1620   /*
1621     Figure out a q size based on the key size.  FIPS 180-3 says:
1622
1623     L = 1024, N = 160
1624     L = 2048, N = 224
1625     L = 2048, N = 256
1626     L = 3072, N = 256
1627
1628     2048/256 is an odd pair since there is also a 2048/224 and
1629     3072/256.  Matching sizes is not a very exact science.
1630
1631     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
1632     but less than 2048, and 160 for 1024 (DSA1).
1633   */
1634
1635   if (nbits > 2047)
1636     qbits = 256;
1637   else if ( nbits > 1024)
1638     qbits = 224;
1639   else
1640     qbits = 160;
1641
1642   if (qbits != 160 )
1643     log_info (_("WARNING: some OpenPGP programs can't"
1644                 " handle a DSA key with this digest size\n"));
1645
1646   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1647   snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
1648   keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)%s))",
1649                            strlen (nbitsstr), nbitsstr,
1650                            strlen (qbitsstr), qbitsstr,
1651                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1652                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1653                            "(transient-key)" : "" );
1654   if (!keyparms)
1655     err = gpg_error_from_syserror ();
1656   else
1657     {
1658       err = common_gen (keyparms, PUBKEY_ALGO_DSA, "pqgy",
1659                         pub_root, timestamp, expireval, is_subkey,
1660                         keygen_flags, passphrase,
1661                         cache_nonce_addr, passwd_nonce_addr);
1662       xfree (keyparms);
1663     }
1664
1665   return err;
1666 }
1667
1668
1669
1670 /*
1671  * Generate an ECC key
1672  */
1673 static gpg_error_t
1674 gen_ecc (int algo, const char *curve, kbnode_t pub_root,
1675          u32 timestamp, u32 expireval, int is_subkey,
1676          int keygen_flags, const char *passphrase,
1677          char **cache_nonce_addr, char **passwd_nonce_addr)
1678 {
1679   gpg_error_t err;
1680   char *keyparms;
1681
1682   log_assert (algo == PUBKEY_ALGO_ECDSA
1683               || algo == PUBKEY_ALGO_EDDSA
1684               || algo == PUBKEY_ALGO_ECDH);
1685
1686   if (!curve || !*curve)
1687     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
1688
1689   /* Map the displayed short forms of some curves to their canonical
1690    * names. */
1691   if (!ascii_strcasecmp (curve, "cv25519"))
1692     curve = "Curve25519";
1693   else if (!ascii_strcasecmp (curve, "ed25519"))
1694     curve = "Ed25519";
1695
1696   /* Note that we use the "comp" flag with EdDSA to request the use of
1697      a 0x40 compression prefix octet.  */
1698   if (algo == PUBKEY_ALGO_EDDSA)
1699     keyparms = xtryasprintf
1700       ("(genkey(ecc(curve %zu:%s)(flags eddsa comp%s)))",
1701        strlen (curve), curve,
1702        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1703          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1704         " transient-key" : ""));
1705   else if (algo == PUBKEY_ALGO_ECDH && !strcmp (curve, "Curve25519"))
1706     keyparms = xtryasprintf
1707       ("(genkey(ecc(curve %zu:%s)(flags djb-tweak comp%s)))",
1708        strlen (curve), curve,
1709        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1710          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1711         " transient-key" : ""));
1712   else
1713     keyparms = xtryasprintf
1714       ("(genkey(ecc(curve %zu:%s)(flags nocomp%s)))",
1715        strlen (curve), curve,
1716        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1717          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1718         " transient-key" : ""));
1719
1720   if (!keyparms)
1721     err = gpg_error_from_syserror ();
1722   else
1723     {
1724       err = common_gen (keyparms, algo, "",
1725                         pub_root, timestamp, expireval, is_subkey,
1726                         keygen_flags, passphrase,
1727                         cache_nonce_addr, passwd_nonce_addr);
1728       xfree (keyparms);
1729     }
1730
1731   return err;
1732 }
1733
1734
1735 /*
1736  * Generate an RSA key.
1737  */
1738 static int
1739 gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
1740          u32 timestamp, u32 expireval, int is_subkey,
1741          int keygen_flags, const char *passphrase,
1742          char **cache_nonce_addr, char **passwd_nonce_addr)
1743 {
1744   int err;
1745   char *keyparms;
1746   char nbitsstr[35];
1747   const unsigned maxsize = (opt.flags.large_rsa ? 8192 : 4096);
1748
1749   log_assert (is_RSA(algo));
1750
1751   if (!nbits)
1752     nbits = get_keysize_range (algo, NULL, NULL);
1753
1754   if (nbits < 1024)
1755     {
1756       nbits = 3072;
1757       log_info (_("keysize invalid; using %u bits\n"), nbits );
1758     }
1759   else if (nbits > maxsize)
1760     {
1761       nbits = maxsize;
1762       log_info (_("keysize invalid; using %u bits\n"), nbits );
1763     }
1764
1765   if ((nbits % 32))
1766     {
1767       nbits = ((nbits + 31) / 32) * 32;
1768       log_info (_("keysize rounded up to %u bits\n"), nbits );
1769     }
1770
1771   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1772   keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)%s))",
1773                            strlen (nbitsstr), nbitsstr,
1774                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1775                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1776                            "(transient-key)" : "" );
1777   if (!keyparms)
1778     err = gpg_error_from_syserror ();
1779   else
1780     {
1781       err = common_gen (keyparms, algo, "ne",
1782                         pub_root, timestamp, expireval, is_subkey,
1783                         keygen_flags, passphrase,
1784                         cache_nonce_addr, passwd_nonce_addr);
1785       xfree (keyparms);
1786     }
1787
1788   return err;
1789 }
1790
1791
1792 /****************
1793  * check valid days:
1794  * return 0 on error or the multiplier
1795  */
1796 static int
1797 check_valid_days( const char *s )
1798 {
1799     if( !digitp(s) )
1800         return 0;
1801     for( s++; *s; s++)
1802         if( !digitp(s) )
1803             break;
1804     if( !*s )
1805         return 1;
1806     if( s[1] )
1807         return 0; /* e.g. "2323wc" */
1808     if( *s == 'd' || *s == 'D' )
1809         return 1;
1810     if( *s == 'w' || *s == 'W' )
1811         return 7;
1812     if( *s == 'm' || *s == 'M' )
1813         return 30;
1814     if( *s == 'y' || *s == 'Y' )
1815         return 365;
1816     return 0;
1817 }
1818
1819
1820 static void
1821 print_key_flags(int flags)
1822 {
1823   if(flags&PUBKEY_USAGE_SIG)
1824     tty_printf("%s ",_("Sign"));
1825
1826   if(flags&PUBKEY_USAGE_CERT)
1827     tty_printf("%s ",_("Certify"));
1828
1829   if(flags&PUBKEY_USAGE_ENC)
1830     tty_printf("%s ",_("Encrypt"));
1831
1832   if(flags&PUBKEY_USAGE_AUTH)
1833     tty_printf("%s ",_("Authenticate"));
1834 }
1835
1836
1837 /* Ask for the key flags and return them.  CURRENT gives the current
1838  * usage which should normally be given as 0. */
1839 unsigned int
1840 ask_key_flags (int algo, int subkey, unsigned int current)
1841 {
1842   /* TRANSLATORS: Please use only plain ASCII characters for the
1843      translation.  If this is not possible use single digits.  The
1844      string needs to 8 bytes long. Here is a description of the
1845      functions:
1846
1847        s = Toggle signing capability
1848        e = Toggle encryption capability
1849        a = Toggle authentication capability
1850        q = Finish
1851   */
1852   const char *togglers = _("SsEeAaQq");
1853   char *answer = NULL;
1854   const char *s;
1855   unsigned int possible = openpgp_pk_algo_usage(algo);
1856
1857   if ( strlen(togglers) != 8 )
1858     {
1859       tty_printf ("NOTE: Bad translation at %s:%d. "
1860                   "Please report.\n", __FILE__, __LINE__);
1861       togglers = "11223300";
1862     }
1863
1864   /* Only primary keys may certify. */
1865   if(subkey)
1866     possible&=~PUBKEY_USAGE_CERT;
1867
1868   /* Preload the current set with the possible set, minus
1869      authentication if CURRENT has been given as 0.  If CURRENT has
1870      been has non-zero we mask with all possible usages. */
1871   if (current)
1872     current &= possible;
1873   else
1874     current = (possible&~PUBKEY_USAGE_AUTH);
1875
1876   for(;;)
1877     {
1878       tty_printf("\n");
1879       tty_printf(_("Possible actions for a %s key: "),
1880                  (algo == PUBKEY_ALGO_ECDSA
1881                   || algo == PUBKEY_ALGO_EDDSA)
1882                  ? "ECDSA/EdDSA" : openpgp_pk_algo_name (algo));
1883       print_key_flags(possible);
1884       tty_printf("\n");
1885       tty_printf(_("Current allowed actions: "));
1886       print_key_flags(current);
1887       tty_printf("\n\n");
1888
1889       if(possible&PUBKEY_USAGE_SIG)
1890         tty_printf(_("   (%c) Toggle the sign capability\n"),
1891                    togglers[0]);
1892       if(possible&PUBKEY_USAGE_ENC)
1893         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1894                    togglers[2]);
1895       if(possible&PUBKEY_USAGE_AUTH)
1896         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1897                    togglers[4]);
1898
1899       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1900       tty_printf("\n");
1901
1902       xfree(answer);
1903       answer = cpr_get("keygen.flags",_("Your selection? "));
1904       cpr_kill_prompt();
1905
1906       if (*answer == '=')
1907         {
1908           /* Hack to allow direct entry of the capabilities.  */
1909           current = 0;
1910           for (s=answer+1; *s; s++)
1911             {
1912               if ((*s == 's' || *s == 'S') && (possible&PUBKEY_USAGE_SIG))
1913                 current |= PUBKEY_USAGE_SIG;
1914               else if ((*s == 'e' || *s == 'E') && (possible&PUBKEY_USAGE_ENC))
1915                 current |= PUBKEY_USAGE_ENC;
1916               else if ((*s == 'a' || *s == 'A') && (possible&PUBKEY_USAGE_AUTH))
1917                 current |= PUBKEY_USAGE_AUTH;
1918               else if (!subkey && *s == 'c')
1919                 {
1920                   /* Accept 'c' for the primary key because USAGE_CERT
1921                      will be set anyway.  This is for folks who
1922                      want to experiment with a cert-only primary key.  */
1923                   current |= PUBKEY_USAGE_CERT;
1924                 }
1925             }
1926           break;
1927         }
1928       else if (strlen(answer)>1)
1929         tty_printf(_("Invalid selection.\n"));
1930       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1931         break;
1932       else if((*answer==togglers[0] || *answer==togglers[1])
1933               && possible&PUBKEY_USAGE_SIG)
1934         {
1935           if(current&PUBKEY_USAGE_SIG)
1936             current&=~PUBKEY_USAGE_SIG;
1937           else
1938             current|=PUBKEY_USAGE_SIG;
1939         }
1940       else if((*answer==togglers[2] || *answer==togglers[3])
1941               && possible&PUBKEY_USAGE_ENC)
1942         {
1943           if(current&PUBKEY_USAGE_ENC)
1944             current&=~PUBKEY_USAGE_ENC;
1945           else
1946             current|=PUBKEY_USAGE_ENC;
1947         }
1948       else if((*answer==togglers[4] || *answer==togglers[5])
1949               && possible&PUBKEY_USAGE_AUTH)
1950         {
1951           if(current&PUBKEY_USAGE_AUTH)
1952             current&=~PUBKEY_USAGE_AUTH;
1953           else
1954             current|=PUBKEY_USAGE_AUTH;
1955         }
1956       else
1957         tty_printf(_("Invalid selection.\n"));
1958     }
1959
1960   xfree(answer);
1961
1962   return current;
1963 }
1964
1965
1966 /* Check whether we have a key for the key with HEXGRIP.  Returns 0 if
1967    there is no such key or the OpenPGP algo number for the key.  */
1968 static int
1969 check_keygrip (ctrl_t ctrl, const char *hexgrip)
1970 {
1971   gpg_error_t err;
1972   unsigned char *public;
1973   size_t publiclen;
1974   int algo;
1975
1976   if (hexgrip[0] == '&')
1977     hexgrip++;
1978
1979   err = agent_readkey (ctrl, 0, hexgrip, &public);
1980   if (err)
1981     return 0;
1982   publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);
1983
1984   algo = get_pk_algo_from_canon_sexp (public, publiclen);
1985   xfree (public);
1986
1987   return map_pk_gcry_to_openpgp (algo);
1988 }
1989
1990
1991
1992 /* Ask for an algorithm.  The function returns the algorithm id to
1993  * create. If ADDMODE is false the function won't show an option to
1994  * create the primary and subkey combined and won't set R_USAGE
1995  * either.  If a combined algorithm has been selected, the subkey
1996  * algorithm is stored at R_SUBKEY_ALGO.  If R_KEYGRIP is given, the
1997  * user has the choice to enter the keygrip of an existing key.  That
1998  * keygrip is then stored at this address.  The caller needs to free
1999  * it. */
2000 static int
2001 ask_algo (ctrl_t ctrl, int addmode, int *r_subkey_algo, unsigned int *r_usage,
2002           char **r_keygrip)
2003 {
2004   char *keygrip = NULL;
2005   char *answer = NULL;
2006   int algo;
2007   int dummy_algo;
2008
2009   if (!r_subkey_algo)
2010     r_subkey_algo = &dummy_algo;
2011
2012   tty_printf (_("Please select what kind of key you want:\n"));
2013
2014 #if GPG_USE_RSA
2015   if (!addmode)
2016     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
2017 #endif
2018
2019   if (!addmode && opt.compliance != CO_DE_VS)
2020     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
2021
2022   if (opt.compliance != CO_DE_VS)
2023     tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
2024 #if GPG_USE_RSA
2025   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
2026 #endif
2027
2028   if (addmode)
2029     {
2030       if (opt.compliance != CO_DE_VS)
2031         tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
2032 #if GPG_USE_RSA
2033       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
2034 #endif
2035     }
2036   if (opt.expert)
2037     {
2038       if (opt.compliance != CO_DE_VS)
2039         tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
2040 #if GPG_USE_RSA
2041       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
2042 #endif
2043     }
2044
2045 #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
2046   if (opt.expert && !addmode)
2047     tty_printf (_("   (%d) ECC and ECC\n"), 9 );
2048   if (opt.expert)
2049     tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
2050   if (opt.expert)
2051     tty_printf (_("  (%d) ECC (set your own capabilities)\n"), 11 );
2052   if (opt.expert && addmode)
2053     tty_printf (_("  (%d) ECC (encrypt only)\n"), 12 );
2054 #endif
2055
2056   if (opt.expert && r_keygrip)
2057     tty_printf (_("  (%d) Existing key\n"), 13 );
2058
2059   for (;;)
2060     {
2061       *r_usage = 0;
2062       *r_subkey_algo = 0;
2063       xfree (answer);
2064       answer = cpr_get ("keygen.algo", _("Your selection? "));
2065       cpr_kill_prompt ();
2066       algo = *answer? atoi (answer) : 1;
2067
2068       if (opt.compliance == CO_DE_VS
2069           && (algo == 2 || algo == 3 || algo == 5 || algo == 7))
2070         {
2071           tty_printf (_("Invalid selection.\n"));
2072         }
2073       else if ((algo == 1 || !strcmp (answer, "rsa+rsa")) && !addmode)
2074         {
2075           algo = PUBKEY_ALGO_RSA;
2076           *r_subkey_algo = PUBKEY_ALGO_RSA;
2077           break;
2078         }
2079       else if ((algo == 2 || !strcmp (answer, "dsa+elg")) && !addmode)
2080         {
2081           algo = PUBKEY_ALGO_DSA;
2082           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
2083           break;
2084         }
2085       else if (algo == 3 || !strcmp (answer, "dsa"))
2086         {
2087           algo = PUBKEY_ALGO_DSA;
2088           *r_usage = PUBKEY_USAGE_SIG;
2089           break;
2090         }
2091       else if (algo == 4 || !strcmp (answer, "rsa/s"))
2092         {
2093           algo = PUBKEY_ALGO_RSA;
2094           *r_usage = PUBKEY_USAGE_SIG;
2095           break;
2096         }
2097       else if ((algo == 5 || !strcmp (answer, "elg")) && addmode)
2098         {
2099           algo = PUBKEY_ALGO_ELGAMAL_E;
2100           *r_usage = PUBKEY_USAGE_ENC;
2101           break;
2102         }
2103       else if ((algo == 6 || !strcmp (answer, "rsa/e")) && addmode)
2104         {
2105           algo = PUBKEY_ALGO_RSA;
2106           *r_usage = PUBKEY_USAGE_ENC;
2107           break;
2108         }
2109       else if ((algo == 7 || !strcmp (answer, "dsa/*")) && opt.expert)
2110         {
2111           algo = PUBKEY_ALGO_DSA;
2112           *r_usage = ask_key_flags (algo, addmode, 0);
2113           break;
2114         }
2115       else if ((algo == 8 || !strcmp (answer, "rsa/*")) && opt.expert)
2116         {
2117           algo = PUBKEY_ALGO_RSA;
2118           *r_usage = ask_key_flags (algo, addmode, 0);
2119           break;
2120         }
2121       else if ((algo == 9 || !strcmp (answer, "ecc+ecc"))
2122                && opt.expert && !addmode)
2123         {
2124           algo = PUBKEY_ALGO_ECDSA;
2125           *r_subkey_algo = PUBKEY_ALGO_ECDH;
2126           break;
2127         }
2128       else if ((algo == 10 || !strcmp (answer, "ecc/s")) && opt.expert)
2129         {
2130           algo = PUBKEY_ALGO_ECDSA;
2131           *r_usage = PUBKEY_USAGE_SIG;
2132           break;
2133         }
2134       else if ((algo == 11 || !strcmp (answer, "ecc/*")) && opt.expert)
2135         {
2136           algo = PUBKEY_ALGO_ECDSA;
2137           *r_usage = ask_key_flags (algo, addmode, 0);
2138           break;
2139         }
2140       else if ((algo == 12 || !strcmp (answer, "ecc/e"))
2141                && opt.expert && addmode)
2142         {
2143           algo = PUBKEY_ALGO_ECDH;
2144           *r_usage = PUBKEY_USAGE_ENC;
2145           break;
2146         }
2147       else if ((algo == 13 || !strcmp (answer, "keygrip"))
2148                && opt.expert && r_keygrip)
2149         {
2150           for (;;)
2151             {
2152               xfree (answer);
2153               answer = tty_get (_("Enter the keygrip: "));
2154               tty_kill_prompt ();
2155               trim_spaces (answer);
2156               if (!*answer)
2157                 {
2158                   xfree (answer);
2159                   answer = NULL;
2160                   continue;
2161                 }
2162
2163               if (strlen (answer) != 40 &&
2164                        !(answer[0] == '&' && strlen (answer+1) == 40))
2165                 tty_printf
2166                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
2167               else if (!(algo = check_keygrip (ctrl, answer)) )
2168                 tty_printf (_("No key with this keygrip\n"));
2169               else
2170                 break; /* Okay.  */
2171             }
2172           xfree (keygrip);
2173           keygrip = answer;
2174           answer = NULL;
2175           *r_usage = ask_key_flags (algo, addmode, 0);
2176           break;
2177         }
2178       else
2179         tty_printf (_("Invalid selection.\n"));
2180
2181     }
2182
2183   xfree(answer);
2184   if (r_keygrip)
2185     *r_keygrip = keygrip;
2186   return algo;
2187 }
2188
2189
2190 static unsigned int
2191 get_keysize_range (int algo, unsigned int *min, unsigned int *max)
2192 {
2193   unsigned int def;
2194   unsigned int dummy1, dummy2;
2195
2196   if (!min)
2197     min = &dummy1;
2198   if (!max)
2199     max = &dummy2;
2200
2201   switch(algo)
2202     {
2203     case PUBKEY_ALGO_DSA:
2204       *min = opt.expert? 768 : 1024;
2205       *max=3072;
2206       def=2048;
2207       break;
2208
2209     case PUBKEY_ALGO_ECDSA:
2210     case PUBKEY_ALGO_ECDH:
2211       *min=256;
2212       *max=521;
2213       def=256;
2214       break;
2215
2216     case PUBKEY_ALGO_EDDSA:
2217       *min=255;
2218       *max=441;
2219       def=255;
2220       break;
2221
2222     default:
2223       *min = opt.compliance == CO_DE_VS ? 2048: 1024;
2224       *max = 4096;
2225       def = 3072;
2226       break;
2227     }
2228
2229   return def;
2230 }
2231
2232
2233 /* Return a fixed up keysize depending on ALGO.  */
2234 static unsigned int
2235 fixup_keysize (unsigned int nbits, int algo, int silent)
2236 {
2237   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
2238     {
2239       nbits = ((nbits + 63) / 64) * 64;
2240       if (!silent)
2241         tty_printf (_("rounded up to %u bits\n"), nbits);
2242     }
2243   else if (algo == PUBKEY_ALGO_EDDSA)
2244     {
2245       if (nbits != 255 && nbits != 441)
2246         {
2247           if (nbits < 256)
2248             nbits = 255;
2249           else
2250             nbits = 441;
2251           if (!silent)
2252             tty_printf (_("rounded to %u bits\n"), nbits);
2253         }
2254     }
2255   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2256     {
2257       if (nbits != 256 && nbits != 384 && nbits != 521)
2258         {
2259           if (nbits < 256)
2260             nbits = 256;
2261           else if (nbits < 384)
2262             nbits = 384;
2263           else
2264             nbits = 521;
2265           if (!silent)
2266             tty_printf (_("rounded to %u bits\n"), nbits);
2267         }
2268     }
2269   else if ((nbits % 32))
2270     {
2271       nbits = ((nbits + 31) / 32) * 32;
2272       if (!silent)
2273         tty_printf (_("rounded up to %u bits\n"), nbits );
2274     }
2275
2276   return nbits;
2277 }
2278
2279
2280 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
2281    is not 0, the function asks for the size of the encryption
2282    subkey. */
2283 static unsigned
2284 ask_keysize (int algo, unsigned int primary_keysize)
2285 {
2286   unsigned int nbits;
2287   unsigned int min, def, max;
2288   int for_subkey = !!primary_keysize;
2289   int autocomp = 0;
2290
2291   def = get_keysize_range (algo, &min, &max);
2292
2293   if (primary_keysize && !opt.expert)
2294     {
2295       /* Deduce the subkey size from the primary key size.  */
2296       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
2297         nbits = 3072; /* For performance reasons we don't support more
2298                          than 3072 bit DSA.  However we won't see this
2299                          case anyway because DSA can't be used as an
2300                          encryption subkey ;-). */
2301       else
2302         nbits = primary_keysize;
2303       autocomp = 1;
2304       goto leave;
2305     }
2306
2307   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
2308              openpgp_pk_algo_name (algo), min, max);
2309
2310   for (;;)
2311     {
2312       char *prompt, *answer;
2313
2314       if (for_subkey)
2315         prompt = xasprintf (_("What keysize do you want "
2316                               "for the subkey? (%u) "), def);
2317       else
2318         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
2319       answer = cpr_get ("keygen.size", prompt);
2320       cpr_kill_prompt ();
2321       nbits = *answer? atoi (answer): def;
2322       xfree(prompt);
2323       xfree(answer);
2324
2325       if(nbits<min || nbits>max)
2326         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
2327                    openpgp_pk_algo_name (algo), min, max);
2328       else
2329         break;
2330     }
2331
2332   tty_printf (_("Requested keysize is %u bits\n"), nbits);
2333
2334  leave:
2335   nbits = fixup_keysize (nbits, algo, autocomp);
2336   return nbits;
2337 }
2338
2339
2340 /* Ask for the curve.  ALGO is the selected algorithm which this
2341    function may adjust.  Returns a const string of the name of the
2342    curve.  */
2343 const char *
2344 ask_curve (int *algo, int *subkey_algo, const char *current)
2345 {
2346   /* NB: We always use a complete algo list so that we have stable
2347      numbers in the menu regardless on how Gpg was configured.  */
2348   struct {
2349     const char *name;
2350     const char* eddsa_curve; /* Corresponding EdDSA curve.  */
2351     const char *pretty_name;
2352     unsigned int supported : 1;   /* Supported by gpg.     */
2353     unsigned int de_vs : 1;       /* Allowed in CO_DE_VS.  */
2354     unsigned int expert_only : 1; /* Only with --expert    */
2355     unsigned int available : 1;   /* Available in Libycrypt (runtime checked) */
2356   } curves[] = {
2357 #if GPG_USE_ECDSA || GPG_USE_ECDH
2358 # define MY_USE_ECDSADH 1
2359 #else
2360 # define MY_USE_ECDSADH 0
2361 #endif
2362     { "Curve25519",      "Ed25519", "Curve 25519", !!GPG_USE_EDDSA, 0, 0, 0 },
2363     { "Curve448",        "Ed448",   "Curve 448",   0/*reserved*/  , 0, 1, 0 },
2364     { "NIST P-256",      NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2365     { "NIST P-384",      NULL, NULL,               MY_USE_ECDSADH,  0, 0, 0 },
2366     { "NIST P-521",      NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2367     { "brainpoolP256r1", NULL, "Brainpool P-256",  MY_USE_ECDSADH,  1, 1, 0 },
2368     { "brainpoolP384r1", NULL, "Brainpool P-384",  MY_USE_ECDSADH,  1, 1, 0 },
2369     { "brainpoolP512r1", NULL, "Brainpool P-512",  MY_USE_ECDSADH,  1, 1, 0 },
2370     { "secp256k1",       NULL, NULL,               MY_USE_ECDSADH,  0, 1, 0 },
2371   };
2372 #undef MY_USE_ECDSADH
2373   int idx;
2374   char *answer;
2375   const char *result = NULL;
2376   gcry_sexp_t keyparms;
2377
2378   tty_printf (_("Please select which elliptic curve you want:\n"));
2379
2380   keyparms = NULL;
2381   for (idx=0; idx < DIM(curves); idx++)
2382     {
2383       int rc;
2384
2385       curves[idx].available = 0;
2386       if (!curves[idx].supported)
2387         continue;
2388
2389       if (opt.compliance==CO_DE_VS)
2390         {
2391           if (!curves[idx].de_vs)
2392             continue; /* Not allowed.  */
2393         }
2394       else if (!opt.expert && curves[idx].expert_only)
2395         continue;
2396
2397       /* We need to switch from the ECDH name of the curve to the
2398          EDDSA name of the curve if we want a signing key.  */
2399       gcry_sexp_release (keyparms);
2400       rc = gcry_sexp_build (&keyparms, NULL,
2401                             "(public-key(ecc(curve %s)))",
2402                             curves[idx].eddsa_curve? curves[idx].eddsa_curve
2403                             /**/                   : curves[idx].name);
2404       if (rc)
2405         continue;
2406       if (!gcry_pk_get_curve (keyparms, 0, NULL))
2407         continue;
2408       if (subkey_algo && curves[idx].eddsa_curve)
2409         {
2410           /* Both Curve 25519 (or 448) keys are to be created.  Check that
2411              Libgcrypt also supports the real Curve25519 (or 448).  */
2412           gcry_sexp_release (keyparms);
2413           rc = gcry_sexp_build (&keyparms, NULL,
2414                                 "(public-key(ecc(curve %s)))",
2415                                  curves[idx].name);
2416           if (rc)
2417             continue;
2418           if (!gcry_pk_get_curve (keyparms, 0, NULL))
2419             continue;
2420         }
2421
2422       curves[idx].available = 1;
2423       tty_printf ("   (%d) %s\n", idx + 1,
2424                   curves[idx].pretty_name?
2425                   curves[idx].pretty_name:curves[idx].name);
2426     }
2427   gcry_sexp_release (keyparms);
2428
2429
2430   for (;;)
2431     {
2432       answer = cpr_get ("keygen.curve", _("Your selection? "));
2433       cpr_kill_prompt ();
2434       idx = *answer? atoi (answer) : 1;
2435       if (!*answer && current)
2436         {
2437           xfree(answer);
2438           return NULL;
2439         }
2440       else if (*answer && !idx)
2441         {
2442           /* See whether the user entered the name of the curve.  */
2443           for (idx=0; idx < DIM(curves); idx++)
2444             {
2445               if (!opt.expert && curves[idx].expert_only)
2446                 continue;
2447               if (!stricmp (curves[idx].name, answer)
2448                   || (curves[idx].pretty_name
2449                       && !stricmp (curves[idx].pretty_name, answer)))
2450                 break;
2451             }
2452           if (idx == DIM(curves))
2453             idx = -1;
2454         }
2455       else
2456         idx--;
2457       xfree(answer);
2458       answer = NULL;
2459       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
2460         tty_printf (_("Invalid selection.\n"));
2461       else
2462         {
2463           /* If the user selected a signing algorithm and Curve25519
2464              we need to set the algo to EdDSA and update the curve name. */
2465           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
2466               && curves[idx].eddsa_curve)
2467             {
2468               if (subkey_algo && *subkey_algo == PUBKEY_ALGO_ECDSA)
2469                 *subkey_algo = PUBKEY_ALGO_EDDSA;
2470               *algo = PUBKEY_ALGO_EDDSA;
2471               result = curves[idx].eddsa_curve;
2472             }
2473           else
2474             result = curves[idx].name;
2475           break;
2476         }
2477     }
2478
2479   if (!result)
2480     result = curves[0].name;
2481
2482   return result;
2483 }
2484
2485
2486 /****************
2487  * Parse an expire string and return its value in seconds.
2488  * Returns (u32)-1 on error.
2489  * This isn't perfect since scan_isodatestr returns unix time, and
2490  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
2491  * Because of this, we only permit setting expirations up to 2106, but
2492  * OpenPGP could theoretically allow up to 2242.  I think we'll all
2493  * just cope for the next few years until we get a 64-bit time_t or
2494  * similar.
2495  */
2496 u32
2497 parse_expire_string( const char *string )
2498 {
2499   int mult;
2500   u32 seconds;
2501   u32 abs_date = 0;
2502   u32 curtime = make_timestamp ();
2503   time_t tt;
2504
2505   if (!string || !*string || !strcmp (string, "none")
2506       || !strcmp (string, "never") || !strcmp (string, "-"))
2507     seconds = 0;
2508   else if (!strncmp (string, "seconds=", 8))
2509     seconds = atoi (string+8);
2510   else if ((abs_date = scan_isodatestr(string))
2511            && (abs_date+86400/2) > curtime)
2512     seconds = (abs_date+86400/2) - curtime;
2513   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
2514     seconds = (u32)tt - curtime;
2515   else if ((mult = check_valid_days (string)))
2516     seconds = atoi (string) * 86400L * mult;
2517   else
2518     seconds = (u32)(-1);
2519
2520   return seconds;
2521 }
2522
2523 /* Parse a Creation-Date string which is either "1986-04-26" or
2524    "19860426T042640".  Returns 0 on error. */
2525 static u32
2526 parse_creation_string (const char *string)
2527 {
2528   u32 seconds;
2529
2530   if (!*string)
2531     seconds = 0;
2532   else if ( !strncmp (string, "seconds=", 8) )
2533     seconds = atoi (string+8);
2534   else if ( !(seconds = scan_isodatestr (string)))
2535     {
2536       time_t tmp = isotime2epoch (string);
2537       seconds = (tmp == (time_t)(-1))? 0 : tmp;
2538     }
2539   return seconds;
2540 }
2541
2542
2543 /* object == 0 for a key, and 1 for a sig */
2544 u32
2545 ask_expire_interval(int object,const char *def_expire)
2546 {
2547     u32 interval;
2548     char *answer;
2549
2550     switch(object)
2551       {
2552       case 0:
2553         if(def_expire)
2554           BUG();
2555         tty_printf(_("Please specify how long the key should be valid.\n"
2556                      "         0 = key does not expire\n"
2557                      "      <n>  = key expires in n days\n"
2558                      "      <n>w = key expires in n weeks\n"
2559                      "      <n>m = key expires in n months\n"
2560                      "      <n>y = key expires in n years\n"));
2561         break;
2562
2563       case 1:
2564         if(!def_expire)
2565           BUG();
2566         tty_printf(_("Please specify how long the signature should be valid.\n"
2567                      "         0 = signature does not expire\n"
2568                      "      <n>  = signature expires in n days\n"
2569                      "      <n>w = signature expires in n weeks\n"
2570                      "      <n>m = signature expires in n months\n"
2571                      "      <n>y = signature expires in n years\n"));
2572         break;
2573
2574       default:
2575         BUG();
2576       }
2577
2578     /* Note: The elgamal subkey for DSA has no expiration date because
2579      * it must be signed with the DSA key and this one has the expiration
2580      * date */
2581
2582     answer = NULL;
2583     for(;;)
2584       {
2585         u32 curtime;
2586
2587         xfree(answer);
2588         if(object==0)
2589           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
2590         else
2591           {
2592             char *prompt;
2593
2594             prompt = xasprintf (_("Signature is valid for? (%s) "), def_expire);
2595             answer = cpr_get("siggen.valid",prompt);
2596             xfree(prompt);
2597
2598             if(*answer=='\0')
2599               answer=xstrdup(def_expire);
2600           }
2601         cpr_kill_prompt();
2602         trim_spaces(answer);
2603         curtime = make_timestamp ();
2604         interval = parse_expire_string( answer );
2605         if( interval == (u32)-1 )
2606           {
2607             tty_printf(_("invalid value\n"));
2608             continue;
2609           }
2610
2611         if( !interval )
2612           {
2613             tty_printf((object==0)
2614                        ? _("Key does not expire at all\n")
2615                        : _("Signature does not expire at all\n"));
2616           }
2617         else
2618           {
2619             tty_printf(object==0
2620                        ? _("Key expires at %s\n")
2621                        : _("Signature expires at %s\n"),
2622                        asctimestamp((ulong)(curtime + interval) ) );
2623 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
2624             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2625               tty_printf (_("Your system can't display dates beyond 2038.\n"
2626                             "However, it will be correctly handled up to"
2627                             " 2106.\n"));
2628             else
2629 #endif /*SIZEOF_TIME_T*/
2630               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2631                 {
2632                   tty_printf (_("invalid value\n"));
2633                   continue;
2634                 }
2635           }
2636
2637         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2638                                                    _("Is this correct? (y/N) ")) )
2639           break;
2640       }
2641
2642     xfree(answer);
2643     return interval;
2644 }
2645
2646 u32
2647 ask_expiredate()
2648 {
2649     u32 x = ask_expire_interval(0,NULL);
2650     return x? make_timestamp() + x : 0;
2651 }
2652
2653
2654
2655 static PKT_user_id *
2656 uid_from_string (const char *string)
2657 {
2658   size_t n;
2659   PKT_user_id *uid;
2660
2661   n = strlen (string);
2662   uid = xmalloc_clear (sizeof *uid + n);
2663   uid->len = n;
2664   strcpy (uid->name, string);
2665   uid->ref = 1;
2666   return uid;
2667 }
2668
2669
2670 /* Return true if the user id UID already exists in the keyblock.  */
2671 static int
2672 uid_already_in_keyblock (kbnode_t keyblock, const char *uid)
2673 {
2674   PKT_user_id *uidpkt = uid_from_string (uid);
2675   kbnode_t node;
2676   int result = 0;
2677
2678   for (node=keyblock; node && !result; node=node->next)
2679     if (!is_deleted_kbnode (node)
2680         && node->pkt->pkttype == PKT_USER_ID
2681         && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2682       result = 1;
2683   free_user_id (uidpkt);
2684   return result;
2685 }
2686
2687
2688 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2689    printed for use during a new key creation.  If KEYBLOCK is not NULL
2690    the function prevents the creation of an already existing user
2691    ID.  IF FULL is not set some prompts are not shown.  */
2692 static char *
2693 ask_user_id (int mode, int full, KBNODE keyblock)
2694 {
2695     char *answer;
2696     char *aname, *acomment, *amail, *uid;
2697
2698     if ( !mode )
2699       {
2700         /* TRANSLATORS: This is the new string telling the user what
2701            gpg is now going to do (i.e. ask for the parts of the user
2702            ID).  Note that if you do not translate this string, a
2703            different string will be used, which might still have
2704            a correct translation.  */
2705         const char *s1 =
2706           N_("\n"
2707              "GnuPG needs to construct a user ID to identify your key.\n"
2708              "\n");
2709         const char *s2 = _(s1);
2710
2711         if (!strcmp (s1, s2))
2712           {
2713             /* There is no translation for the string thus we to use
2714                the old info text.  gettext has no way to tell whether
2715                a translation is actually available, thus we need to
2716                to compare again. */
2717             /* TRANSLATORS: This string is in general not anymore used
2718                but you should keep your existing translation.  In case
2719                the new string is not translated this old string will
2720                be used. */
2721             const char *s3 = N_("\n"
2722 "You need a user ID to identify your key; "
2723                                         "the software constructs the user ID\n"
2724 "from the Real Name, Comment and Email Address in this form:\n"
2725 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2726             const char *s4 = _(s3);
2727             if (strcmp (s3, s4))
2728               s2 = s3; /* A translation exists - use it. */
2729           }
2730         tty_printf ("%s", s2) ;
2731       }
2732     uid = aname = acomment = amail = NULL;
2733     for(;;) {
2734         char *p;
2735         int fail=0;
2736
2737         if( !aname ) {
2738             for(;;) {
2739                 xfree(aname);
2740                 aname = cpr_get("keygen.name",_("Real name: "));
2741                 trim_spaces(aname);
2742                 cpr_kill_prompt();
2743
2744                 if( opt.allow_freeform_uid )
2745                     break;
2746
2747                 if( strpbrk( aname, "<>" ) )
2748                   {
2749                     tty_printf(_("Invalid character in name\n"));
2750                     tty_printf(_("The characters '%s' and '%s' may not "
2751                                  "appear in name\n"), "<", ">");
2752                   }
2753                 else if( digitp(aname) )
2754                     tty_printf(_("Name may not start with a digit\n"));
2755                 else if (*aname && strlen (aname) < 5)
2756                   {
2757                     tty_printf(_("Name must be at least 5 characters long\n"));
2758                     /* However, we allow an empty name.  */
2759                   }
2760                 else
2761                     break;
2762             }
2763         }
2764         if( !amail ) {
2765             for(;;) {
2766                 xfree(amail);
2767                 amail = cpr_get("keygen.email",_("Email address: "));
2768                 trim_spaces(amail);
2769                 cpr_kill_prompt();
2770                 if( !*amail || opt.allow_freeform_uid )
2771                     break;   /* no email address is okay */
2772                 else if ( !is_valid_mailbox (amail) )
2773                     tty_printf(_("Not a valid email address\n"));
2774                 else
2775                     break;
2776             }
2777         }
2778         if (!acomment) {
2779           if (full) {
2780             for(;;) {
2781                 xfree(acomment);
2782                 acomment = cpr_get("keygen.comment",_("Comment: "));
2783                 trim_spaces(acomment);
2784                 cpr_kill_prompt();
2785                 if( !*acomment )
2786                     break;   /* no comment is okay */
2787                 else if( strpbrk( acomment, "()" ) )
2788                     tty_printf(_("Invalid character in comment\n"));
2789                 else
2790                     break;
2791             }
2792           }
2793           else {
2794             xfree (acomment);
2795             acomment = xstrdup ("");
2796           }
2797         }
2798
2799
2800         xfree(uid);
2801         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2802         if (!*aname && *amail && !*acomment && !random_is_faked ())
2803           { /* Empty name and comment but with mail address.  Use
2804                simplified form with only the non-angle-bracketed mail
2805                address.  */
2806             p = stpcpy (p, amail);
2807           }
2808         else
2809           {
2810             p = stpcpy (p, aname );
2811             if (*acomment)
2812               p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2813             if (*amail)
2814               p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2815           }
2816
2817         /* Append a warning if the RNG is switched into fake mode.  */
2818         if ( random_is_faked ()  )
2819           strcpy(p, " (insecure!)" );
2820
2821         /* print a note in case that UTF8 mapping has to be done */
2822         for(p=uid; *p; p++ ) {
2823             if( *p & 0x80 ) {
2824                 tty_printf(_("You are using the '%s' character set.\n"),
2825                            get_native_charset() );
2826                 break;
2827             }
2828         }
2829
2830         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2831
2832         if( !*amail && !opt.allow_freeform_uid
2833             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2834             fail = 1;
2835             tty_printf(_("Please don't put the email address "
2836                          "into the real name or the comment\n") );
2837         }
2838
2839         if (!fail && keyblock)
2840           {
2841             if (uid_already_in_keyblock (keyblock, uid))
2842               {
2843                 tty_printf (_("Such a user ID already exists on this key!\n"));
2844                 fail = 1;
2845               }
2846           }
2847
2848         for(;;) {
2849             /* TRANSLATORS: These are the allowed answers in
2850                lower and uppercase.  Below you will find the matching
2851                string which should be translated accordingly and the
2852                letter changed to match the one in the answer string.
2853
2854                  n = Change name
2855                  c = Change comment
2856                  e = Change email
2857                  o = Okay (ready, continue)
2858                  q = Quit
2859              */
2860             const char *ansstr = _("NnCcEeOoQq");
2861
2862             if( strlen(ansstr) != 10 )
2863                 BUG();
2864             if( cpr_enabled() ) {
2865                 answer = xstrdup (ansstr + (fail?8:6));
2866                 answer[1] = 0;
2867             }
2868             else if (full) {
2869                 answer = cpr_get("keygen.userid.cmd", fail?
2870                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2871                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2872                 cpr_kill_prompt();
2873             }
2874             else {
2875                 answer = cpr_get("keygen.userid.cmd", fail?
2876                   _("Change (N)ame, (E)mail, or (Q)uit? ") :
2877                   _("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
2878                 cpr_kill_prompt();
2879             }
2880             if( strlen(answer) > 1 )
2881                 ;
2882             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2883                 xfree(aname); aname = NULL;
2884                 break;
2885             }
2886             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2887                 xfree(acomment); acomment = NULL;
2888                 break;
2889             }
2890             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2891                 xfree(amail); amail = NULL;
2892                 break;
2893             }
2894             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2895                 if( fail ) {
2896                     tty_printf(_("Please correct the error first\n"));
2897                 }
2898                 else {
2899                     xfree(aname); aname = NULL;
2900                     xfree(acomment); acomment = NULL;
2901                     xfree(amail); amail = NULL;
2902                     break;
2903                 }
2904             }
2905             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2906                 xfree(aname); aname = NULL;
2907                 xfree(acomment); acomment = NULL;
2908                 xfree(amail); amail = NULL;
2909                 xfree(uid); uid = NULL;
2910                 break;
2911             }
2912             xfree(answer);
2913         }
2914         xfree(answer);
2915         if (!amail && !acomment)
2916             break;
2917         xfree(uid); uid = NULL;
2918     }
2919     if( uid ) {
2920         char *p = native_to_utf8( uid );
2921         xfree( uid );
2922         uid = p;
2923     }
2924     return uid;
2925 }
2926
2927
2928 /* Basic key generation.  Here we divert to the actual generation
2929    routines based on the requested algorithm.  */
2930 static int
2931 do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
2932            u32 timestamp, u32 expiredate, int is_subkey,
2933            int keygen_flags, const char *passphrase,
2934            char **cache_nonce_addr, char **passwd_nonce_addr)
2935 {
2936   gpg_error_t err;
2937
2938   /* Fixme: The entropy collecting message should be moved to a
2939      libgcrypt progress handler.  */
2940   if (!opt.batch)
2941     tty_printf (_(
2942 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2943 "some other action (type on the keyboard, move the mouse, utilize the\n"
2944 "disks) during the prime generation; this gives the random number\n"
2945 "generator a better chance to gain enough entropy.\n") );
2946
2947   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2948     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2949                    keygen_flags, passphrase,
2950                    cache_nonce_addr, passwd_nonce_addr);
2951   else if (algo == PUBKEY_ALGO_DSA)
2952     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2953                    keygen_flags, passphrase,
2954                    cache_nonce_addr, passwd_nonce_addr);
2955   else if (algo == PUBKEY_ALGO_ECDSA
2956            || algo == PUBKEY_ALGO_EDDSA
2957            || algo == PUBKEY_ALGO_ECDH)
2958     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
2959                    keygen_flags, passphrase,
2960                    cache_nonce_addr, passwd_nonce_addr);
2961   else if (algo == PUBKEY_ALGO_RSA)
2962     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2963                    keygen_flags, passphrase,
2964                    cache_nonce_addr, passwd_nonce_addr);
2965   else
2966     BUG();
2967
2968   return err;
2969 }
2970
2971
2972 /* Generate a new user id packet or return NULL if canceled.  If
2973    KEYBLOCK is not NULL the function prevents the creation of an
2974    already existing user ID.  If UIDSTR is not NULL the user is not
2975    asked but UIDSTR is used to create the user id packet; if the user
2976    id already exists NULL is returned.  UIDSTR is expected to be utf-8
2977    encoded and should have already been checked for a valid length
2978    etc.  */
2979 PKT_user_id *
2980 generate_user_id (KBNODE keyblock, const char *uidstr)
2981 {
2982   PKT_user_id *uid;
2983   char *p;
2984
2985   if (uidstr)
2986     {
2987       if (uid_already_in_keyblock (keyblock, uidstr))
2988         return NULL;  /* Already exists.  */
2989       uid = uid_from_string (uidstr);
2990     }
2991   else
2992     {
2993       p = ask_user_id (1, 1, keyblock);
2994       if (!p)
2995         return NULL;  /* Canceled. */
2996       uid = uid_from_string (p);
2997       xfree (p);
2998     }
2999   return uid;
3000 }
3001
3002
3003 /* Helper for parse_key_parameter_string for one part of the
3004  * specification string; i.e.  ALGO/FLAGS.  If STRING is NULL or empty
3005  * success is returned.  On error an error code is returned.  Note
3006  * that STRING may be modified by this function.  NULL may be passed
3007  * for any parameter.  FOR_SUBKEY shall be true if this is used as a
3008  * subkey.  If CLEAR_CERT is set a default CERT usage will be cleared;
3009  * this is useful if for example the default algorithm is used for a
3010  * subkey.  */
3011 static gpg_error_t
3012 parse_key_parameter_part (char *string, int for_subkey, int clear_cert,
3013                           int *r_algo, unsigned int *r_size,
3014                           unsigned int *r_keyuse,
3015                           char const **r_curve)
3016 {
3017   char *flags;
3018   int algo;
3019   char *endp;
3020   const char *curve = NULL;
3021   int ecdh_or_ecdsa = 0;
3022   unsigned int size;
3023   int keyuse;
3024   int i;
3025   const char *s;
3026
3027   if (!string || !*string)
3028     return 0; /* Success.  */
3029
3030   flags = strchr (string, '/');
3031   if (flags)
3032     *flags++ = 0;
3033
3034   algo = 0;
3035   if (strlen (string) >= 3 && (digitp (string+3) || !string[3]))
3036     {
3037       if (!ascii_memcasecmp (string, "rsa", 3))
3038         algo = PUBKEY_ALGO_RSA;
3039       else if (!ascii_memcasecmp (string, "dsa", 3))
3040         algo = PUBKEY_ALGO_DSA;
3041       else if (!ascii_memcasecmp (string, "elg", 3))
3042         algo = PUBKEY_ALGO_ELGAMAL_E;
3043     }
3044   if (algo)
3045     {
3046       if (!string[3])
3047         size = get_keysize_range (algo, NULL, NULL);
3048       else
3049         {
3050           size = strtoul (string+3, &endp, 10);
3051           if (size < 512 || size > 16384 || *endp)
3052             return gpg_error (GPG_ERR_INV_VALUE);
3053         }
3054     }
3055   else if ((curve = openpgp_is_curve_supported (string, &algo, &size)))
3056     {
3057       if (!algo)
3058         {
3059           algo = PUBKEY_ALGO_ECDH; /* Default ECC algorithm.  */
3060           ecdh_or_ecdsa = 1;       /* We may need to switch the algo.  */
3061         }
3062     }
3063   else
3064     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
3065
3066   /* Parse the flags.  */
3067   keyuse = 0;
3068   if (flags)
3069     {
3070       char **tokens = NULL;
3071
3072       tokens = strtokenize (flags, ",");
3073       if (!tokens)
3074         return gpg_error_from_syserror ();
3075
3076       for (i=0; (s = tokens[i]); i++)
3077         {
3078           if (!*s)
3079             ;
3080           else if (!ascii_strcasecmp (s, "sign"))
3081             keyuse |= PUBKEY_USAGE_SIG;
3082           else if (!ascii_strcasecmp (s, "encrypt")
3083                    || !ascii_strcasecmp (s, "encr"))
3084             keyuse |= PUBKEY_USAGE_ENC;
3085           else if (!ascii_strcasecmp (s, "auth"))
3086             keyuse |= PUBKEY_USAGE_AUTH;
3087           else if (!ascii_strcasecmp (s, "cert"))
3088             keyuse |= PUBKEY_USAGE_CERT;
3089           else if (!ascii_strcasecmp (s, "ecdsa"))
3090             {
3091               if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
3092                 algo = PUBKEY_ALGO_ECDSA;
3093               else
3094                 {
3095                   xfree (tokens);
3096                   return gpg_error (GPG_ERR_INV_FLAG);
3097                 }
3098               ecdh_or_ecdsa = 0;
3099             }
3100           else if (!ascii_strcasecmp (s, "ecdh"))
3101             {
3102               if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
3103                 algo = PUBKEY_ALGO_ECDH;
3104               else
3105                 {
3106                   xfree (tokens);
3107                   return gpg_error (GPG_ERR_INV_FLAG);
3108                 }
3109               ecdh_or_ecdsa = 0;
3110             }
3111           else if (!ascii_strcasecmp (s, "eddsa"))
3112             {
3113               /* Not required but we allow it for consistency.  */
3114               if (algo == PUBKEY_ALGO_EDDSA)
3115                 ;
3116               else
3117                 {
3118                   xfree (tokens);
3119                   return gpg_error (GPG_ERR_INV_FLAG);
3120                 }
3121             }
3122           else
3123             {
3124               xfree (tokens);
3125               return gpg_error (GPG_ERR_UNKNOWN_FLAG);
3126             }
3127         }
3128
3129       xfree (tokens);
3130     }
3131
3132   /* If not yet decided switch between ecdh and ecdsa.  */
3133   if (ecdh_or_ecdsa && keyuse)
3134     algo = (keyuse & PUBKEY_USAGE_ENC)? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_ECDSA;
3135   else if (ecdh_or_ecdsa)
3136     algo = for_subkey? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_ECDSA;
3137
3138   /* Set or fix key usage.  */
3139   if (!keyuse)
3140     {
3141       if (algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_EDDSA
3142           || algo == PUBKEY_ALGO_DSA)
3143         keyuse = PUBKEY_USAGE_SIG;
3144       else if (algo == PUBKEY_ALGO_RSA)
3145         keyuse = for_subkey? PUBKEY_USAGE_ENC : PUBKEY_USAGE_SIG;
3146       else
3147         keyuse = PUBKEY_USAGE_ENC;
3148     }
3149   else if (algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_EDDSA
3150            || algo == PUBKEY_ALGO_DSA)
3151     {
3152       keyuse &= ~PUBKEY_USAGE_ENC; /* Forbid encryption.  */
3153     }
3154   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ELGAMAL_E)
3155     {
3156       keyuse = PUBKEY_USAGE_ENC;   /* Allow only encryption.  */
3157     }
3158
3159   /* Make sure a primary key can certify.  */
3160   if (!for_subkey)
3161     keyuse |= PUBKEY_USAGE_CERT;
3162
3163   /* But if requested remove th cert usage.  */
3164   if (clear_cert)
3165     keyuse &= ~PUBKEY_USAGE_CERT;
3166
3167   /* Check that usage is actually possible.  */
3168   if (/**/((keyuse & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH|PUBKEY_USAGE_CERT))
3169            && !pubkey_get_nsig (algo))
3170        || ((keyuse & PUBKEY_USAGE_ENC)
3171            && !pubkey_get_nenc (algo))
3172        || (for_subkey && (keyuse & PUBKEY_USAGE_CERT)))
3173     return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
3174
3175   /* Return values.  */
3176   if (r_algo)
3177     *r_algo = algo;
3178   if (r_size)
3179     {
3180       unsigned int min, def, max;
3181
3182       /* Make sure the keysize is in the allowed range.  */
3183       def = get_keysize_range (algo, &min, &max);
3184       if (!size)
3185         size = def;
3186       else if (size < min)
3187         size = min;
3188       else if (size > max)
3189         size = max;
3190
3191       *r_size = fixup_keysize (size, algo, 1);
3192     }
3193   if (r_keyuse)
3194     *r_keyuse = keyuse;
3195   if (r_curve)
3196     *r_curve = curve;
3197
3198   return 0;
3199 }
3200
3201 /* Parse and return the standard key generation parameter.
3202  * The string is expected to be in this format:
3203  *
3204  *   ALGO[/FLAGS][+SUBALGO[/FLAGS]]
3205  *
3206  * Here ALGO is a string in the same format as printed by the
3207  * keylisting.  For example:
3208  *
3209  *   rsa3072 := RSA with 3072 bit.
3210  *   dsa2048 := DSA with 2048 bit.
3211  *   elg2048 := Elgamal with 2048 bit.
3212  *   ed25519 := EDDSA using curve Ed25519.
3213  *   cv25519 := ECDH using curve Curve25519.
3214  *   nistp256:= ECDSA or ECDH using curve NIST P-256
3215  *
3216  * All strings with an unknown prefix are considered an elliptic
3217  * curve.  Curves which have no implicit algorithm require that FLAGS
3218  * is given to select whether ECDSA or ECDH is used; this can eoither
3219  * be done using an algorithm keyword or usage keywords.
3220  *
3221  * FLAGS is a comma delimited string of keywords:
3222  *
3223  *   cert := Allow usage Certify
3224  *   sign := Allow usage Sign
3225  *   encr := Allow usage Encrypt
3226  *   auth := Allow usage Authentication
3227  *   encrypt := Alias for "encr"
3228  *   ecdsa := Use algorithm ECDSA.
3229  *   eddsa := Use algorithm EdDSA.
3230  *   ecdh  := Use algorithm ECDH.
3231  *
3232  * There are several defaults and fallbacks depending on the
3233  * algorithm.  PART can be used to select which part of STRING is
3234  * used:
3235  *   -1 := Both parts
3236  *    0 := Only the part of the primary key
3237  *    1 := If there is one part parse that one, if there are
3238  *         two parts parse the part which best matches the
3239  *         SUGGESTED_USE or in case that can't be evaluated the second part.
3240  *         Always return using the args for the primary key (R_ALGO,....).
3241  *
3242  */
3243 gpg_error_t
3244 parse_key_parameter_string (const char *string, int part,
3245                             unsigned int suggested_use,
3246                             int *r_algo, unsigned int *r_size,
3247                             unsigned int *r_keyuse,
3248                             char const **r_curve,
3249                             int *r_subalgo, unsigned int *r_subsize,
3250                             unsigned *r_subkeyuse,
3251                             char const **r_subcurve)
3252 {
3253   gpg_error_t err = 0;
3254   char *primary, *secondary;
3255
3256   if (r_algo)
3257     *r_algo = 0;
3258   if (r_size)
3259     *r_size = 0;
3260   if (r_keyuse)
3261     *r_keyuse = 0;
3262   if (r_curve)
3263     *r_curve = NULL;
3264   if (r_subalgo)
3265     *r_subalgo = 0;
3266   if (r_subsize)
3267     *r_subsize = 0;
3268   if (r_subkeyuse)
3269     *r_subkeyuse = 0;
3270   if (r_subcurve)
3271     *r_subcurve = NULL;
3272
3273   if (!string || !*string
3274       || !ascii_strcasecmp (string, "default") || !strcmp (string, "-"))
3275     string = get_default_pubkey_algo ();
3276   else if (!ascii_strcasecmp (string, "future-default")
3277            || !ascii_strcasecmp (string, "futuredefault"))
3278     string = FUTURE_STD_KEY_PARAM;
3279
3280   primary = xstrdup (string);
3281   secondary = strchr (primary, '+');
3282   if (secondary)
3283     *secondary++ = 0;
3284   if (part == -1 || part == 0)
3285     {
3286       err = parse_key_parameter_part (primary, 0, 0, r_algo, r_size,
3287                                       r_keyuse, r_curve);
3288       if (!err && part == -1)
3289         err = parse_key_parameter_part (secondary, 1, 0, r_subalgo, r_subsize,
3290                                         r_subkeyuse, r_subcurve);
3291     }
3292   else if (part == 1)
3293     {
3294       /* If we have SECONDARY, use that part.  If there is only one
3295        * part consider this to be the subkey algo.  In case a
3296        * SUGGESTED_USE has been given and the usage of the secondary
3297        * part does not match SUGGESTED_USE try again using the primary
3298        * part.  Note that when falling back to the primary key we need
3299        * to force clearing the cert usage. */
3300       if (secondary)
3301         {
3302           err = parse_key_parameter_part (secondary, 1, 0,
3303                                           r_algo, r_size, r_keyuse, r_curve);
3304           if (!err && suggested_use && r_keyuse && !(suggested_use & *r_keyuse))
3305             err = parse_key_parameter_part (primary, 1, 1 /*(clear cert)*/,
3306                                             r_algo, r_size, r_keyuse, r_curve);
3307         }
3308       else
3309         err = parse_key_parameter_part (primary, 1, 0,
3310                                         r_algo, r_size, r_keyuse, r_curve);
3311     }
3312
3313   xfree (primary);
3314
3315   return err;
3316 }
3317
3318
3319
3320 /* Append R to the linked list PARA.  */
3321 static void
3322 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
3323 {
3324   log_assert (para);
3325   while (para->next)
3326     para = para->next;
3327   para->next = r;
3328 }
3329
3330 /* Release the parameter list R.  */
3331 static void
3332 release_parameter_list (struct para_data_s *r)
3333 {
3334   struct para_data_s *r2;
3335
3336   for (; r ; r = r2)
3337     {
3338       r2 = r->next;
3339       if (r->key == pPASSPHRASE && *r->u.value)
3340         wipememory (r->u.value, strlen (r->u.value));
3341       xfree (r);
3342     }
3343 }
3344
3345 static struct para_data_s *
3346 get_parameter( struct para_data_s *para, enum para_name key )
3347 {
3348     struct para_data_s *r;
3349
3350     for( r = para; r && r->key != key; r = r->next )
3351         ;
3352     return r;
3353 }
3354
3355 static const char *
3356 get_parameter_value( struct para_data_s *para, enum para_name key )
3357 {
3358     struct para_data_s *r = get_parameter( para, key );
3359     return (r && *r->u.value)? r->u.value : NULL;
3360 }
3361
3362
3363 /* This is similar to get_parameter_value but also returns the empty
3364    string.  This is required so that quick_generate_keypair can use an
3365    empty Passphrase to specify no-protection.  */
3366 static const char *
3367 get_parameter_passphrase (struct para_data_s *para)
3368 {
3369   struct para_data_s *r = get_parameter (para, pPASSPHRASE);
3370   return r ? r->u.value : NULL;
3371 }
3372
3373
3374 static int
3375 get_parameter_algo( struct para_data_s *para, enum para_name key,
3376                     int *r_default)
3377 {
3378   int i;
3379   struct para_data_s *r = get_parameter( para, key );
3380
3381   if (r_default)
3382     *r_default = 0;
3383
3384   if (!r)
3385     return -1;
3386
3387   /* Note that we need to handle the ECC algorithms specified as
3388      strings directly because Libgcrypt folds them all to ECC.  */
3389   if (!ascii_strcasecmp (r->u.value, "default"))
3390     {
3391       /* Note: If you change this default algo, remember to change it
3392        * also in gpg.c:gpgconf_list.  */
3393       /* FIXME: We only allow the algo here and have a separate thing
3394        * for the curve etc.  That is a ugly but demanded for backward
3395        * compatibility with the batch key generation.  It would be
3396        * better to make full use of parse_key_parameter_string.  */
3397       parse_key_parameter_string (NULL, 0, 0,
3398                                   &i, NULL, NULL, NULL,
3399                                   NULL, NULL, NULL, NULL);
3400
3401       if (r_default)
3402         *r_default = 1;
3403     }
3404   else if (digitp (r->u.value))
3405     i = atoi( r->u.value );
3406   else if (!strcmp (r->u.value, "ELG-E")
3407            || !strcmp (r->u.value, "ELG"))
3408     i = PUBKEY_ALGO_ELGAMAL_E;
3409   else if (!ascii_strcasecmp (r->u.value, "EdDSA"))
3410     i = PUBKEY_ALGO_EDDSA;
3411   else if (!ascii_strcasecmp (r->u.value, "ECDSA"))
3412     i = PUBKEY_ALGO_ECDSA;
3413   else if (!ascii_strcasecmp (r->u.value, "ECDH"))
3414     i = PUBKEY_ALGO_ECDH;
3415   else
3416     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
3417
3418   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
3419     i = 0; /* we don't want to allow generation of these algorithms */
3420   return i;
3421 }
3422
3423
3424 /* Parse a usage string.  The usage keywords "auth", "sign", "encr"
3425  * may be delimited by space, tab, or comma.  On error -1 is returned
3426  * instead of the usage flags.  */
3427 static int
3428 parse_usagestr (const char *usagestr)
3429 {
3430   gpg_error_t err;
3431   char **tokens = NULL;
3432   const char *s;
3433   int i;
3434   unsigned int use = 0;
3435
3436   tokens = strtokenize (usagestr, " \t,");
3437   if (!tokens)
3438     {
3439       err = gpg_error_from_syserror ();
3440       log_error ("strtokenize failed: %s\n", gpg_strerror (err));
3441       return -1;
3442     }
3443
3444   for (i=0; (s = tokens[i]); i++)
3445     {
3446       if (!*s)
3447         ;
3448       else if (!ascii_strcasecmp (s, "sign"))
3449         use |= PUBKEY_USAGE_SIG;
3450       else if (!ascii_strcasecmp (s, "encrypt")
3451                 || !ascii_strcasecmp (s, "encr"))
3452         use |= PUBKEY_USAGE_ENC;
3453       else if (!ascii_strcasecmp (s, "auth"))
3454         use |= PUBKEY_USAGE_AUTH;
3455       else if (!ascii_strcasecmp (s, "cert"))
3456         use |= PUBKEY_USAGE_CERT;
3457       else
3458         {
3459           xfree (tokens);
3460           return -1; /* error */
3461         }
3462     }
3463
3464   xfree (tokens);
3465   return use;
3466 }
3467
3468
3469 /*
3470  * Parse the usage parameter and set the keyflags.  Returns -1 on
3471  * error, 0 for no usage given or 1 for usage available.
3472  */
3473 static int
3474 parse_parameter_usage (const char *fname,
3475                        struct para_data_s *para, enum para_name key)
3476 {
3477   struct para_data_s *r = get_parameter( para, key );
3478   int i;
3479
3480   if (!r)
3481     return 0; /* none (this is an optional parameter)*/
3482
3483   i = parse_usagestr (r->u.value);
3484   if (i == -1)
3485     {
3486       log_error ("%s:%d: invalid usage list\n", fname, r->lnr );
3487       return -1; /* error */
3488     }
3489
3490   r->u.usage = i;
3491   return 1;
3492 }
3493
3494
3495 static int
3496 parse_revocation_key (const char *fname,
3497                       struct para_data_s *para, enum para_name key)
3498 {
3499   struct para_data_s *r = get_parameter( para, key );
3500   struct revocation_key revkey;
3501   char *pn;
3502   int i;
3503
3504   if( !r )
3505     return 0; /* none (this is an optional parameter) */
3506
3507   pn = r->u.value;
3508
3509   revkey.class=0x80;
3510   revkey.algid=atoi(pn);
3511   if(!revkey.algid)
3512     goto fail;
3513
3514   /* Skip to the fpr */
3515   while(*pn && *pn!=':')
3516     pn++;
3517
3518   if(*pn!=':')
3519     goto fail;
3520
3521   pn++;
3522
3523   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
3524     {
3525       int c=hextobyte(pn);
3526       if(c==-1)
3527         goto fail;
3528
3529       revkey.fpr[i]=c;
3530     }
3531   if (i != 20 && i != 32)
3532     goto fail;
3533
3534   /* skip to the tag */
3535   while(*pn && *pn!='s' && *pn!='S')
3536     pn++;
3537
3538   if(ascii_strcasecmp(pn,"sensitive")==0)
3539     revkey.class|=0x40;
3540
3541   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
3542
3543   return 0;
3544
3545  fail:
3546   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
3547   return -1; /* error */
3548 }
3549
3550
3551 static u32
3552 get_parameter_u32( struct para_data_s *para, enum para_name key )
3553 {
3554   struct para_data_s *r = get_parameter( para, key );
3555
3556   if( !r )
3557     return 0;
3558   if( r->key == pKEYCREATIONDATE )
3559     return r->u.creation;
3560   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
3561     return r->u.expire;
3562   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
3563     return r->u.usage;
3564
3565   return (unsigned int)strtoul( r->u.value, NULL, 10 );
3566 }
3567
3568 static unsigned int
3569 get_parameter_uint( struct para_data_s *para, enum para_name key )
3570 {
3571     return get_parameter_u32( para, key );
3572 }
3573
3574 static struct revocation_key *
3575 get_parameter_revkey( struct para_data_s *para, enum para_name key )
3576 {
3577     struct para_data_s *r = get_parameter( para, key );
3578     return r? &r->u.revkey : NULL;
3579 }
3580
3581 static int
3582 proc_parameter_file (ctrl_t ctrl, struct para_data_s *para, const char *fname,
3583                      struct output_control_s *outctrl, int card )
3584 {
3585   struct para_data_s *r;
3586   const char *s1, *s2, *s3;
3587   size_t n;
3588   char *p;
3589   int is_default = 0;
3590   int have_user_id = 0;
3591   int err, algo;
3592
3593   /* Check that we have all required parameters. */
3594   r = get_parameter( para, pKEYTYPE );
3595   if(r)
3596     {
3597       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
3598       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
3599         {
3600           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3601           return -1;
3602         }
3603     }
3604   else
3605     {
3606       log_error ("%s: no Key-Type specified\n",fname);
3607       return -1;
3608     }
3609
3610   err = parse_parameter_usage (fname, para, pKEYUSAGE);
3611   if (!err)
3612     {
3613       /* Default to algo capabilities if key-usage is not provided and
3614          no default algorithm has been requested.  */
3615       r = xmalloc_clear(sizeof(*r));
3616       r->key = pKEYUSAGE;
3617       r->u.usage = (is_default
3618                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
3619                     : openpgp_pk_algo_usage(algo));
3620       append_to_parameter (para, r);
3621     }
3622   else if (err == -1)
3623     return -1;
3624   else
3625     {
3626       r = get_parameter (para, pKEYUSAGE);
3627       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3628         {
3629           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
3630                      fname, r->lnr, algo);
3631           return -1;
3632         }
3633     }
3634
3635   is_default = 0;
3636   r = get_parameter( para, pSUBKEYTYPE );
3637   if(r)
3638     {
3639       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
3640       if (openpgp_pk_test_algo (algo))
3641         {
3642           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3643           return -1;
3644         }
3645
3646       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
3647       if (!err)
3648         {
3649           /* Default to algo capabilities if subkey-usage is not
3650              provided */