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