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