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