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