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