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