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