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