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