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