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