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