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