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