gpg: Simplify command --gen-key and add --full-gen-key.
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - generate a key pair
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3  *               2007, 2009, 2010, 2011  Free Software Foundation, Inc.
4  * Copyright (C) 2014  Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <errno.h>
28 #include <assert.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <unistd.h>
32
33 #include "gpg.h"
34 #include "util.h"
35 #include "main.h"
36 #include "packet.h"
37 #include "ttyio.h"
38 #include "options.h"
39 #include "keydb.h"
40 #include "trustdb.h"
41 #include "status.h"
42 #include "i18n.h"
43 #include "keyserver-internal.h"
44 #include "call-agent.h"
45 #include "pkglue.h"
46
47 /* The default algorithms.  If you change them remember to change them
48    also in gpg.c:gpgconf_list.  You should also check that the value
49    is inside the bounds enforced by ask_keysize and gen_xxx.  */
50 #define DEFAULT_STD_ALGO       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             }
1722           break;
1723         }
1724       else if (strlen(answer)>1)
1725         tty_printf(_("Invalid selection.\n"));
1726       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1727         break;
1728       else if((*answer==togglers[0] || *answer==togglers[1])
1729               && possible&PUBKEY_USAGE_SIG)
1730         {
1731           if(current&PUBKEY_USAGE_SIG)
1732             current&=~PUBKEY_USAGE_SIG;
1733           else
1734             current|=PUBKEY_USAGE_SIG;
1735         }
1736       else if((*answer==togglers[2] || *answer==togglers[3])
1737               && possible&PUBKEY_USAGE_ENC)
1738         {
1739           if(current&PUBKEY_USAGE_ENC)
1740             current&=~PUBKEY_USAGE_ENC;
1741           else
1742             current|=PUBKEY_USAGE_ENC;
1743         }
1744       else if((*answer==togglers[4] || *answer==togglers[5])
1745               && possible&PUBKEY_USAGE_AUTH)
1746         {
1747           if(current&PUBKEY_USAGE_AUTH)
1748             current&=~PUBKEY_USAGE_AUTH;
1749           else
1750             current|=PUBKEY_USAGE_AUTH;
1751         }
1752       else
1753         tty_printf(_("Invalid selection.\n"));
1754     }
1755
1756   xfree(answer);
1757
1758   return current;
1759 }
1760
1761
1762 /* Check whether we have a key for the key with HEXGRIP.  Returns 0 if
1763    there is no such key or the OpenPGP algo number for the key.  */
1764 static int
1765 check_keygrip (ctrl_t ctrl, const char *hexgrip)
1766 {
1767   gpg_error_t err;
1768   unsigned char *public;
1769   size_t publiclen;
1770   const char *algostr;
1771
1772   if (hexgrip[0] == '&')
1773     hexgrip++;
1774
1775   err = agent_readkey (ctrl, 0, hexgrip, &public);
1776   if (err)
1777     return 0;
1778   publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);
1779
1780   get_pk_algo_from_canon_sexp (public, publiclen, &algostr);
1781   xfree (public);
1782
1783   /* FIXME: Mapping of ECC algorithms is probably not correct. */
1784   if (!algostr)
1785     return 0;
1786   else if (!strcmp (algostr, "rsa"))
1787     return PUBKEY_ALGO_RSA;
1788   else if (!strcmp (algostr, "dsa"))
1789     return PUBKEY_ALGO_DSA;
1790   else if (!strcmp (algostr, "elg"))
1791     return PUBKEY_ALGO_ELGAMAL_E;
1792   else if (!strcmp (algostr, "ecc"))
1793     return PUBKEY_ALGO_ECDH;
1794   else if (!strcmp (algostr, "ecdsa"))
1795     return PUBKEY_ALGO_ECDSA;
1796   else if (!strcmp (algostr, "eddsa"))
1797     return PUBKEY_ALGO_EDDSA;
1798   else
1799     return 0;
1800 }
1801
1802
1803
1804 /* Ask for an algorithm.  The function returns the algorithm id to
1805  * create. If ADDMODE is false the function won't show an option to
1806  * create the primary and subkey combined and won't set R_USAGE
1807  * either.  If a combined algorithm has been selected, the subkey
1808  * algorithm is stored at R_SUBKEY_ALGO.  If R_KEYGRIP is given, the
1809  * user has the choice to enter the keygrip of an existing key.  That
1810  * keygrip is then stored at this address.  The caller needs to free
1811  * it. */
1812 static int
1813 ask_algo (ctrl_t ctrl, int addmode, int *r_subkey_algo, unsigned int *r_usage,
1814           char **r_keygrip)
1815 {
1816   char *keygrip = NULL;
1817   char *answer;
1818   int algo;
1819   int dummy_algo;
1820
1821   if (!r_subkey_algo)
1822     r_subkey_algo = &dummy_algo;
1823
1824   tty_printf (_("Please select what kind of key you want:\n"));
1825
1826 #if GPG_USE_RSA
1827   if (!addmode)
1828     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1829 #endif
1830
1831   if (!addmode)
1832     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1833
1834   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1835 #if GPG_USE_RSA
1836   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1837 #endif
1838
1839   if (addmode)
1840     {
1841       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1842 #if GPG_USE_RSA
1843       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1844 #endif
1845     }
1846   if (opt.expert)
1847     {
1848       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1849 #if GPG_USE_RSA
1850       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1851 #endif
1852     }
1853
1854 #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
1855   if (opt.expert && !addmode)
1856     tty_printf (_("   (%d) ECC and ECC\n"), 9 );
1857   if (opt.expert)
1858     tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
1859   if (opt.expert)
1860     tty_printf (_("  (%d) ECC (set your own capabilities)\n"), 11 );
1861   if (opt.expert && addmode)
1862     tty_printf (_("  (%d) ECC (encrypt only)\n"), 12 );
1863 #endif
1864
1865   if (opt.expert && r_keygrip)
1866     tty_printf (_("  (%d) Existing key\n"), 13 );
1867
1868   for (;;)
1869     {
1870       *r_usage = 0;
1871       *r_subkey_algo = 0;
1872       answer = cpr_get ("keygen.algo", _("Your selection? "));
1873       cpr_kill_prompt ();
1874       algo = *answer? atoi (answer) : 1;
1875       xfree(answer);
1876       answer = NULL;
1877       if (algo == 1 && !addmode)
1878         {
1879           algo = PUBKEY_ALGO_RSA;
1880           *r_subkey_algo = PUBKEY_ALGO_RSA;
1881           break;
1882         }
1883       else if (algo == 2 && !addmode)
1884         {
1885           algo = PUBKEY_ALGO_DSA;
1886           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1887           break;
1888         }
1889       else if (algo == 3)
1890         {
1891           algo = PUBKEY_ALGO_DSA;
1892           *r_usage = PUBKEY_USAGE_SIG;
1893           break;
1894         }
1895       else if (algo == 4)
1896         {
1897           algo = PUBKEY_ALGO_RSA;
1898           *r_usage = PUBKEY_USAGE_SIG;
1899           break;
1900         }
1901       else if (algo == 5 && addmode)
1902         {
1903           algo = PUBKEY_ALGO_ELGAMAL_E;
1904           *r_usage = PUBKEY_USAGE_ENC;
1905           break;
1906         }
1907       else if (algo == 6 && addmode)
1908         {
1909           algo = PUBKEY_ALGO_RSA;
1910           *r_usage = PUBKEY_USAGE_ENC;
1911           break;
1912         }
1913       else if (algo == 7 && opt.expert)
1914         {
1915           algo = PUBKEY_ALGO_DSA;
1916           *r_usage = ask_key_flags (algo, addmode);
1917           break;
1918         }
1919       else if (algo == 8 && opt.expert)
1920         {
1921           algo = PUBKEY_ALGO_RSA;
1922           *r_usage = ask_key_flags (algo, addmode);
1923           break;
1924         }
1925       else if (algo == 9 && opt.expert && !addmode)
1926         {
1927           algo = PUBKEY_ALGO_ECDSA;
1928           *r_subkey_algo = PUBKEY_ALGO_ECDH;
1929           break;
1930         }
1931       else if (algo == 10 && opt.expert)
1932         {
1933           algo = PUBKEY_ALGO_ECDSA;
1934           *r_usage = PUBKEY_USAGE_SIG;
1935           break;
1936         }
1937       else if (algo == 11 && opt.expert)
1938         {
1939           algo = PUBKEY_ALGO_ECDSA;
1940           *r_usage = ask_key_flags (algo, addmode);
1941           break;
1942         }
1943       else if (algo == 12 && opt.expert && addmode)
1944         {
1945           algo = PUBKEY_ALGO_ECDH;
1946           *r_usage = PUBKEY_USAGE_ENC;
1947           break;
1948         }
1949       else if (algo == 13 && opt.expert && r_keygrip)
1950         {
1951           for (;;)
1952             {
1953               xfree (answer);
1954               answer = tty_get (_("Enter the keygrip: "));
1955               tty_kill_prompt ();
1956               trim_spaces (answer);
1957               if (!*answer)
1958                 {
1959                   xfree (answer);
1960                   answer = NULL;
1961                   continue;
1962                 }
1963
1964               if (strlen (answer) != 40 &&
1965                        !(answer[0] == '&' && strlen (answer+1) == 40))
1966                 tty_printf
1967                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
1968               else if (!(algo = check_keygrip (ctrl, answer)) )
1969                 tty_printf (_("No key with this keygrip\n"));
1970               else
1971                 break; /* Okay.  */
1972             }
1973           xfree (keygrip);
1974           keygrip = answer;
1975           answer = NULL;
1976           *r_usage = ask_key_flags (algo, addmode);
1977           break;
1978         }
1979       else
1980         tty_printf (_("Invalid selection.\n"));
1981     }
1982
1983   if (r_keygrip)
1984     *r_keygrip = keygrip;
1985   return algo;
1986 }
1987
1988
1989 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1990    is not 0, the function asks for the size of the encryption
1991    subkey. */
1992 static unsigned
1993 ask_keysize (int algo, unsigned int primary_keysize)
1994 {
1995   unsigned int nbits, min, def = DEFAULT_STD_KEYSIZE, max=4096;
1996   int for_subkey = !!primary_keysize;
1997   int autocomp = 0;
1998
1999   if(opt.expert)
2000     min=512;
2001   else
2002     min=1024;
2003
2004   if (primary_keysize && !opt.expert)
2005     {
2006       /* Deduce the subkey size from the primary key size.  */
2007       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
2008         nbits = 3072; /* For performance reasons we don't support more
2009                          than 3072 bit DSA.  However we won't see this
2010                          case anyway because DSA can't be used as an
2011                          encryption subkey ;-). */
2012       else
2013         nbits = primary_keysize;
2014       autocomp = 1;
2015       goto leave;
2016     }
2017
2018   switch(algo)
2019     {
2020     case PUBKEY_ALGO_DSA:
2021       def=2048;
2022       max=3072;
2023       break;
2024
2025     case PUBKEY_ALGO_ECDSA:
2026     case PUBKEY_ALGO_ECDH:
2027       min=256;
2028       def=256;
2029       max=521;
2030       break;
2031
2032     case PUBKEY_ALGO_EDDSA:
2033       min=255;
2034       def=255;
2035       max=441;
2036       break;
2037
2038     case PUBKEY_ALGO_RSA:
2039       min=1024;
2040       break;
2041     }
2042
2043   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
2044              openpgp_pk_algo_name (algo), min, max);
2045
2046   for (;;)
2047     {
2048       char *prompt, *answer;
2049
2050       if (for_subkey)
2051         prompt = xasprintf (_("What keysize do you want "
2052                               "for the subkey? (%u) "), def);
2053       else
2054         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
2055       answer = cpr_get ("keygen.size", prompt);
2056       cpr_kill_prompt ();
2057       nbits = *answer? atoi (answer): def;
2058       xfree(prompt);
2059       xfree(answer);
2060
2061       if(nbits<min || nbits>max)
2062         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
2063                    openpgp_pk_algo_name (algo), min, max);
2064       else
2065         break;
2066     }
2067
2068   tty_printf (_("Requested keysize is %u bits\n"), nbits);
2069
2070  leave:
2071   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
2072     {
2073       nbits = ((nbits + 63) / 64) * 64;
2074       if (!autocomp)
2075         tty_printf (_("rounded up to %u bits\n"), nbits);
2076     }
2077   else if (algo == PUBKEY_ALGO_EDDSA)
2078     {
2079       if (nbits != 255 && nbits != 441)
2080         {
2081           if (nbits < 256)
2082             nbits = 255;
2083           else
2084             nbits = 441;
2085           if (!autocomp)
2086             tty_printf (_("rounded to %u bits\n"), nbits);
2087         }
2088     }
2089   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2090     {
2091       if (nbits != 256 && nbits != 384 && nbits != 521)
2092         {
2093           if (nbits < 256)
2094             nbits = 256;
2095           else if (nbits < 384)
2096             nbits = 384;
2097           else
2098             nbits = 521;
2099           if (!autocomp)
2100             tty_printf (_("rounded to %u bits\n"), nbits);
2101         }
2102     }
2103   else if ((nbits % 32))
2104     {
2105       nbits = ((nbits + 31) / 32) * 32;
2106       if (!autocomp)
2107         tty_printf (_("rounded up to %u bits\n"), nbits );
2108     }
2109
2110   return nbits;
2111 }
2112
2113
2114 /* Ask for the curve.  ALGO is the selected algorithm which this
2115    function may adjust.  Returns a malloced string with the name of
2116    the curve.  BOTH tells that gpg creates a primary and subkey. */
2117 static char *
2118 ask_curve (int *algo, int both)
2119 {
2120   struct {
2121     const char *name;
2122     int available;
2123     int expert_only;
2124     int fix_curve;
2125     const char *pretty_name;
2126   } curves[] = {
2127 #if GPG_USE_EDDSA
2128     { "Curve25519",      0, 0, 1, "Curve 25519" },
2129 #endif
2130 #if GPG_USE_ECDSA || GPG_USE_ECDH
2131     { "NIST P-256",      0, 1, 0, },
2132     { "NIST P-384",      0, 0, 0, },
2133     { "NIST P-521",      0, 1, 0, },
2134     { "brainpoolP256r1", 0, 1, 0, "Brainpool P-256" },
2135     { "brainpoolP384r1", 0, 1, 0, "Brainpool P-384" },
2136     { "brainpoolP512r1", 0, 1, 0, "Brainpool P-512" },
2137     { "secp256k1",       0, 1, 0  },
2138 #endif
2139   };
2140   int idx;
2141   char *answer;
2142   char *result = NULL;
2143   gcry_sexp_t keyparms;
2144
2145   tty_printf (_("Please select which elliptic curve you want:\n"));
2146
2147  again:
2148   keyparms = NULL;
2149   for (idx=0; idx < DIM(curves); idx++)
2150     {
2151       int rc;
2152
2153       curves[idx].available = 0;
2154       if (!opt.expert && curves[idx].expert_only)
2155         continue;
2156
2157       /* FIXME: The strcmp below is a temporary hack during
2158          development.  It shall be removed as soon as we have proper
2159          Curve25519 support in Libgcrypt.  */
2160       gcry_sexp_release (keyparms);
2161       rc = gcry_sexp_build (&keyparms, NULL,
2162                             "(public-key(ecc(curve %s)))",
2163                             (!strcmp (curves[idx].name, "Curve25519")
2164                              ? "Ed25519" : curves[idx].name));
2165       if (rc)
2166         continue;
2167       if (!gcry_pk_get_curve (keyparms, 0, NULL))
2168         continue;
2169       if (both && curves[idx].fix_curve)
2170         {
2171           /* Both Curve 25519 keys are to be created.  Check that
2172              Libgcrypt also supports the real Curve25519.  */
2173           gcry_sexp_release (keyparms);
2174           rc = gcry_sexp_build (&keyparms, NULL,
2175                                 "(public-key(ecc(curve %s)))",
2176                                  curves[idx].name);
2177           if (rc)
2178             continue;
2179           if (!gcry_pk_get_curve (keyparms, 0, NULL))
2180             continue;
2181         }
2182
2183       curves[idx].available = 1;
2184       tty_printf ("   (%d) %s\n", idx + 1,
2185                   curves[idx].pretty_name?
2186                   curves[idx].pretty_name:curves[idx].name);
2187     }
2188   gcry_sexp_release (keyparms);
2189
2190
2191   for (;;)
2192     {
2193       answer = cpr_get ("keygen.curve", _("Your selection? "));
2194       cpr_kill_prompt ();
2195       idx = *answer? atoi (answer) : 1;
2196       if (*answer && !idx)
2197         {
2198           /* See whether the user entered the name of the curve.  */
2199           for (idx=0; idx < DIM(curves); idx++)
2200             {
2201               if (!opt.expert && curves[idx].expert_only)
2202                 continue;
2203               if (!stricmp (curves[idx].name, answer)
2204                   || (curves[idx].pretty_name
2205                       && !stricmp (curves[idx].pretty_name, answer)))
2206                 break;
2207             }
2208           if (idx == DIM(curves))
2209             idx = -1;
2210         }
2211       else
2212         idx--;
2213       xfree(answer);
2214       answer = NULL;
2215       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
2216         tty_printf (_("Invalid selection.\n"));
2217       else
2218         {
2219           if (curves[idx].fix_curve)
2220             {
2221               log_info ("WARNING: Curve25519 is not yet part of the"
2222                         " OpenPGP standard.\n");
2223
2224               if (!cpr_get_answer_is_yes("experimental_curve.override",
2225                                          "Use this curve anyway? (y/N) ")  )
2226                 goto again;
2227             }
2228
2229           /* If the user selected a signing algorithm and Curve25519
2230              we need to update the algo and and the curve name.  */
2231           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
2232               && curves[idx].fix_curve)
2233             {
2234               *algo = PUBKEY_ALGO_EDDSA;
2235               result = xstrdup ("Ed25519");
2236             }
2237           else
2238             result = xstrdup (curves[idx].name);
2239           break;
2240         }
2241     }
2242
2243   if (!result)
2244     result = xstrdup (curves[0].name);
2245
2246   return result;
2247 }
2248
2249
2250 /****************
2251  * Parse an expire string and return its value in seconds.
2252  * Returns (u32)-1 on error.
2253  * This isn't perfect since scan_isodatestr returns unix time, and
2254  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
2255  * Because of this, we only permit setting expirations up to 2106, but
2256  * OpenPGP could theoretically allow up to 2242.  I think we'll all
2257  * just cope for the next few years until we get a 64-bit time_t or
2258  * similar.
2259  */
2260 u32
2261 parse_expire_string( const char *string )
2262 {
2263   int mult;
2264   u32 seconds;
2265   u32 abs_date = 0;
2266   u32 curtime = make_timestamp ();
2267   time_t tt;
2268
2269   if (!*string)
2270     seconds = 0;
2271   else if (!strncmp (string, "seconds=", 8))
2272     seconds = atoi (string+8);
2273   else if ((abs_date = scan_isodatestr(string))
2274            && (abs_date+86400/2) > curtime)
2275     seconds = (abs_date+86400/2) - curtime;
2276   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
2277     seconds = (u32)tt - curtime;
2278   else if ((mult = check_valid_days (string)))
2279     seconds = atoi (string) * 86400L * mult;
2280   else
2281     seconds = (u32)(-1);
2282
2283   return seconds;
2284 }
2285
2286 /* Parsean Creation-Date string which is either "1986-04-26" or
2287    "19860426T042640".  Returns 0 on error. */
2288 static u32
2289 parse_creation_string (const char *string)
2290 {
2291   u32 seconds;
2292
2293   if (!*string)
2294     seconds = 0;
2295   else if ( !strncmp (string, "seconds=", 8) )
2296     seconds = atoi (string+8);
2297   else if ( !(seconds = scan_isodatestr (string)))
2298     {
2299       time_t tmp = isotime2epoch (string);
2300       seconds = (tmp == (time_t)(-1))? 0 : tmp;
2301     }
2302   return seconds;
2303 }
2304
2305
2306 /* object == 0 for a key, and 1 for a sig */
2307 u32
2308 ask_expire_interval(int object,const char *def_expire)
2309 {
2310     u32 interval;
2311     char *answer;
2312
2313     switch(object)
2314       {
2315       case 0:
2316         if(def_expire)
2317           BUG();
2318         tty_printf(_("Please specify how long the key should be valid.\n"
2319                      "         0 = key does not expire\n"
2320                      "      <n>  = key expires in n days\n"
2321                      "      <n>w = key expires in n weeks\n"
2322                      "      <n>m = key expires in n months\n"
2323                      "      <n>y = key expires in n years\n"));
2324         break;
2325
2326       case 1:
2327         if(!def_expire)
2328           BUG();
2329         tty_printf(_("Please specify how long the signature should be valid.\n"
2330                      "         0 = signature does not expire\n"
2331                      "      <n>  = signature expires in n days\n"
2332                      "      <n>w = signature expires in n weeks\n"
2333                      "      <n>m = signature expires in n months\n"
2334                      "      <n>y = signature expires in n years\n"));
2335         break;
2336
2337       default:
2338         BUG();
2339       }
2340
2341     /* Note: The elgamal subkey for DSA has no expiration date because
2342      * it must be signed with the DSA key and this one has the expiration
2343      * date */
2344
2345     answer = NULL;
2346     for(;;)
2347       {
2348         u32 curtime;
2349
2350         xfree(answer);
2351         if(object==0)
2352           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
2353         else
2354           {
2355             char *prompt;
2356
2357 #define PROMPTSTRING _("Signature is valid for? (%s) ")
2358             /* This will actually end up larger than necessary because
2359                of the 2 bytes for '%s' */
2360             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
2361             sprintf(prompt,PROMPTSTRING,def_expire);
2362 #undef PROMPTSTRING
2363
2364             answer = cpr_get("siggen.valid",prompt);
2365             xfree(prompt);
2366
2367             if(*answer=='\0')
2368               answer=xstrdup(def_expire);
2369           }
2370         cpr_kill_prompt();
2371         trim_spaces(answer);
2372         curtime = make_timestamp ();
2373         interval = parse_expire_string( answer );
2374         if( interval == (u32)-1 )
2375           {
2376             tty_printf(_("invalid value\n"));
2377             continue;
2378           }
2379
2380         if( !interval )
2381           {
2382             tty_printf((object==0)
2383                        ? _("Key does not expire at all\n")
2384                        : _("Signature does not expire at all\n"));
2385           }
2386         else
2387           {
2388             tty_printf(object==0
2389                        ? _("Key expires at %s\n")
2390                        : _("Signature expires at %s\n"),
2391                        asctimestamp((ulong)(curtime + interval) ) );
2392 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
2393             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2394               tty_printf (_("Your system can't display dates beyond 2038.\n"
2395                             "However, it will be correctly handled up to"
2396                             " 2106.\n"));
2397             else
2398 #endif /*SIZEOF_TIME_T*/
2399               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2400                 {
2401                   tty_printf (_("invalid value\n"));
2402                   continue;
2403                 }
2404           }
2405
2406         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2407                                                    _("Is this correct? (y/N) ")) )
2408           break;
2409       }
2410
2411     xfree(answer);
2412     return interval;
2413 }
2414
2415 u32
2416 ask_expiredate()
2417 {
2418     u32 x = ask_expire_interval(0,NULL);
2419     return x? make_timestamp() + x : 0;
2420 }
2421
2422
2423
2424 static PKT_user_id *
2425 uid_from_string (const char *string)
2426 {
2427   size_t n;
2428   PKT_user_id *uid;
2429
2430   n = strlen (string);
2431   uid = xmalloc_clear (sizeof *uid + n);
2432   uid->len = n;
2433   strcpy (uid->name, string);
2434   uid->ref = 1;
2435   return uid;
2436 }
2437
2438
2439 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2440    printed for use during a new key creation.  If KEYBLOCK is not NULL
2441    the function prevents the creation of an already existing user
2442    ID.  IF FULL is not set some prompts are not shown.  */
2443 static char *
2444 ask_user_id (int mode, int full, KBNODE keyblock)
2445 {
2446     char *answer;
2447     char *aname, *acomment, *amail, *uid;
2448
2449     if ( !mode )
2450       {
2451         /* TRANSLATORS: This is the new string telling the user what
2452            gpg is now going to do (i.e. ask for the parts of the user
2453            ID).  Note that if you do not translate this string, a
2454            different string will be used, which might still have
2455            a correct translation.  */
2456         const char *s1 =
2457           N_("\n"
2458              "GnuPG needs to construct a user ID to identify your key.\n"
2459              "\n");
2460         const char *s2 = _(s1);
2461
2462         if (!strcmp (s1, s2))
2463           {
2464             /* There is no translation for the string thus we to use
2465                the old info text.  gettext has no way to tell whether
2466                a translation is actually available, thus we need to
2467                to compare again. */
2468             /* TRANSLATORS: This string is in general not anymore used
2469                but you should keep your existing translation.  In case
2470                the new string is not translated this old string will
2471                be used. */
2472             const char *s3 = N_("\n"
2473 "You need a user ID to identify your key; "
2474                                         "the software constructs the user ID\n"
2475 "from the Real Name, Comment and Email Address in this form:\n"
2476 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2477             const char *s4 = _(s3);
2478             if (strcmp (s3, s4))
2479               s2 = s3; /* A translation exists - use it. */
2480           }
2481         tty_printf ("%s", s2) ;
2482       }
2483     uid = aname = acomment = amail = NULL;
2484     for(;;) {
2485         char *p;
2486         int fail=0;
2487
2488         if( !aname ) {
2489             for(;;) {
2490                 xfree(aname);
2491                 aname = cpr_get("keygen.name",_("Real name: "));
2492                 trim_spaces(aname);
2493                 cpr_kill_prompt();
2494
2495                 if( opt.allow_freeform_uid )
2496                     break;
2497
2498                 if( strpbrk( aname, "<>" ) )
2499                     tty_printf(_("Invalid character in name\n"));
2500                 else if( digitp(aname) )
2501                     tty_printf(_("Name may not start with a digit\n"));
2502                 else if( strlen(aname) < 5 )
2503                     tty_printf(_("Name must be at least 5 characters long\n"));
2504                 else
2505                     break;
2506             }
2507         }
2508         if( !amail ) {
2509             for(;;) {
2510                 xfree(amail);
2511                 amail = cpr_get("keygen.email",_("Email address: "));
2512                 trim_spaces(amail);
2513                 cpr_kill_prompt();
2514                 if( !*amail || opt.allow_freeform_uid )
2515                     break;   /* no email address is okay */
2516                 else if ( !is_valid_mailbox (amail) )
2517                     tty_printf(_("Not a valid email address\n"));
2518                 else
2519                     break;
2520             }
2521         }
2522         if (!acomment) {
2523           if (full) {
2524             for(;;) {
2525                 xfree(acomment);
2526                 acomment = cpr_get("keygen.comment",_("Comment: "));
2527                 trim_spaces(acomment);
2528                 cpr_kill_prompt();
2529                 if( !*acomment )
2530                     break;   /* no comment is okay */
2531                 else if( strpbrk( acomment, "()" ) )
2532                     tty_printf(_("Invalid character in comment\n"));
2533                 else
2534                     break;
2535             }
2536           }
2537           else {
2538             xfree (acomment);
2539             acomment = xstrdup ("");
2540           }
2541         }
2542
2543
2544         xfree(uid);
2545         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2546         p = stpcpy(p, aname );
2547         if( *acomment )
2548             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2549         if( *amail )
2550             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2551
2552         /* Append a warning if the RNG is switched into fake mode.  */
2553         if ( random_is_faked ()  )
2554           strcpy(p, " (insecure!)" );
2555
2556         /* print a note in case that UTF8 mapping has to be done */
2557         for(p=uid; *p; p++ ) {
2558             if( *p & 0x80 ) {
2559                 tty_printf(_("You are using the '%s' character set.\n"),
2560                            get_native_charset() );
2561                 break;
2562             }
2563         }
2564
2565         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2566
2567         if( !*amail && !opt.allow_freeform_uid
2568             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2569             fail = 1;
2570             tty_printf(_("Please don't put the email address "
2571                          "into the real name or the comment\n") );
2572         }
2573
2574         if (!fail && keyblock)
2575           {
2576             PKT_user_id *uidpkt = uid_from_string (uid);
2577             KBNODE node;
2578
2579             for (node=keyblock; node && !fail; node=node->next)
2580               if (!is_deleted_kbnode (node)
2581                   && node->pkt->pkttype == PKT_USER_ID
2582                   && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2583                 fail = 1;
2584             if (fail)
2585               tty_printf (_("Such a user ID already exists on this key!\n"));
2586             free_user_id (uidpkt);
2587           }
2588
2589         for(;;) {
2590             /* TRANSLATORS: These are the allowed answers in
2591                lower and uppercase.  Below you will find the matching
2592                string which should be translated accordingly and the
2593                letter changed to match the one in the answer string.
2594
2595                  n = Change name
2596                  c = Change comment
2597                  e = Change email
2598                  o = Okay (ready, continue)
2599                  q = Quit
2600              */
2601             const char *ansstr = _("NnCcEeOoQq");
2602
2603             if( strlen(ansstr) != 10 )
2604                 BUG();
2605             if( cpr_enabled() ) {
2606                 answer = xstrdup (ansstr + (fail?8:6));
2607                 answer[1] = 0;
2608             }
2609             else if (full) {
2610                 answer = cpr_get("keygen.userid.cmd", fail?
2611                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2612                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2613                 cpr_kill_prompt();
2614             }
2615             else {
2616                 answer = cpr_get("keygen.userid.cmd", fail?
2617                   _("Change (N)ame, (E)mail, or (Q)uit? ") :
2618                   _("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
2619                 cpr_kill_prompt();
2620             }
2621             if( strlen(answer) > 1 )
2622                 ;
2623             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2624                 xfree(aname); aname = NULL;
2625                 break;
2626             }
2627             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2628                 xfree(acomment); acomment = NULL;
2629                 break;
2630             }
2631             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2632                 xfree(amail); amail = NULL;
2633                 break;
2634             }
2635             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2636                 if( fail ) {
2637                     tty_printf(_("Please correct the error first\n"));
2638                 }
2639                 else {
2640                     xfree(aname); aname = NULL;
2641                     xfree(acomment); acomment = NULL;
2642                     xfree(amail); amail = NULL;
2643                     break;
2644                 }
2645             }
2646             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2647                 xfree(aname); aname = NULL;
2648                 xfree(acomment); acomment = NULL;
2649                 xfree(amail); amail = NULL;
2650                 xfree(uid); uid = NULL;
2651                 break;
2652             }
2653             xfree(answer);
2654         }
2655         xfree(answer);
2656         if( !amail && !acomment && !amail )
2657             break;
2658         xfree(uid); uid = NULL;
2659     }
2660     if( uid ) {
2661         char *p = native_to_utf8( uid );
2662         xfree( uid );
2663         uid = p;
2664     }
2665     return uid;
2666 }
2667
2668
2669 /*  MODE  0 - standard
2670           1 - Ask for passphrase of the card backup key.  */
2671 static DEK *
2672 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2673 {
2674     DEK *dek = NULL;
2675     STRING2KEY *s2k;
2676     const char *errtext = NULL;
2677     const char *custdesc = NULL;
2678
2679     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2680
2681     if (mode == 1)
2682       custdesc = _("Please enter a passphrase to protect the off-card "
2683                    "backup of the new encryption key.");
2684
2685     s2k = xmalloc_secure( sizeof *s2k );
2686     for(;;) {
2687         s2k->mode = opt.s2k_mode;
2688         s2k->hash_algo = S2K_DIGEST_ALGO;
2689         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2690                                      errtext, custdesc, NULL, r_canceled);
2691         if (!dek && *r_canceled) {
2692             xfree(dek); dek = NULL;
2693             xfree(s2k); s2k = NULL;
2694             break;
2695         }
2696         else if( !dek ) {
2697             errtext = N_("passphrase not correctly repeated; try again");
2698             tty_printf(_("%s.\n"), _(errtext));
2699         }
2700         else if( !dek->keylen ) {
2701             xfree(dek); dek = NULL;
2702             xfree(s2k); s2k = NULL;
2703             tty_printf(_(
2704             "You don't want a passphrase - this is probably a *bad* idea!\n"
2705             "I will do it anyway.  You can change your passphrase at any time,\n"
2706             "using this program with the option \"--edit-key\".\n\n"));
2707             break;
2708         }
2709         else
2710             break; /* okay */
2711     }
2712     *ret_s2k = s2k;
2713     return dek;
2714 }
2715
2716
2717 /* Basic key generation.  Here we divert to the actual generation
2718    routines based on the requested algorithm.  */
2719 static int
2720 do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
2721            u32 timestamp, u32 expiredate, int is_subkey,
2722            int keygen_flags, char **cache_nonce_addr)
2723 {
2724   gpg_error_t err;
2725
2726   /* Fixme: The entropy collecting message should be moved to a
2727      libgcrypt progress handler.  */
2728   if (!opt.batch)
2729     tty_printf (_(
2730 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2731 "some other action (type on the keyboard, move the mouse, utilize the\n"
2732 "disks) during the prime generation; this gives the random number\n"
2733 "generator a better chance to gain enough entropy.\n") );
2734
2735   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2736     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2737                    keygen_flags, cache_nonce_addr);
2738   else if (algo == PUBKEY_ALGO_DSA)
2739     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2740                    keygen_flags, cache_nonce_addr);
2741   else if (algo == PUBKEY_ALGO_ECDSA
2742            || algo == PUBKEY_ALGO_EDDSA
2743            || algo == PUBKEY_ALGO_ECDH)
2744     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
2745                    keygen_flags, cache_nonce_addr);
2746   else if (algo == PUBKEY_ALGO_RSA)
2747     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2748                    keygen_flags, cache_nonce_addr);
2749   else
2750     BUG();
2751
2752   return err;
2753 }
2754
2755
2756 /* Generate a new user id packet or return NULL if canceled.  If
2757    KEYBLOCK is not NULL the function prevents the creation of an
2758    already existing user ID.  */
2759 PKT_user_id *
2760 generate_user_id (KBNODE keyblock)
2761 {
2762   char *p;
2763
2764   p = ask_user_id (1, 1, keyblock);
2765   if (!p)
2766     return NULL;  /* Canceled. */
2767   return uid_from_string (p);
2768 }
2769
2770
2771 /* Append R to the linked list PARA.  */
2772 static void
2773 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
2774 {
2775   assert (para);
2776   while (para->next)
2777     para = para->next;
2778   para->next = r;
2779 }
2780
2781 /* Release the parameter list R.  */
2782 static void
2783 release_parameter_list (struct para_data_s *r)
2784 {
2785   struct para_data_s *r2;
2786
2787   for (; r ; r = r2)
2788     {
2789       r2 = r->next;
2790       if (r->key == pPASSPHRASE_DEK)
2791         xfree (r->u.dek);
2792       else if (r->key == pPASSPHRASE_S2K )
2793         xfree (r->u.s2k);
2794
2795       xfree (r);
2796     }
2797 }
2798
2799 static struct para_data_s *
2800 get_parameter( struct para_data_s *para, enum para_name key )
2801 {
2802     struct para_data_s *r;
2803
2804     for( r = para; r && r->key != key; r = r->next )
2805         ;
2806     return r;
2807 }
2808
2809 static const char *
2810 get_parameter_value( struct para_data_s *para, enum para_name key )
2811 {
2812     struct para_data_s *r = get_parameter( para, key );
2813     return (r && *r->u.value)? r->u.value : NULL;
2814 }
2815
2816 static int
2817 get_parameter_algo( struct para_data_s *para, enum para_name key,
2818                     int *r_default)
2819 {
2820   int i;
2821   struct para_data_s *r = get_parameter( para, key );
2822
2823   if (r_default)
2824     *r_default = 0;
2825
2826   if (!r)
2827     return -1;
2828
2829   if (!ascii_strcasecmp (r->u.value, "default"))
2830     {
2831       /* Note: If you change this default algo, remember to change it
2832          also in gpg.c:gpgconf_list.  */
2833       i = DEFAULT_STD_ALGO;
2834       if (r_default)
2835         *r_default = 1;
2836     }
2837   else if (digitp (r->u.value))
2838     i = atoi( r->u.value );
2839   else if (!strcmp (r->u.value, "ELG-E")
2840            || !strcmp (r->u.value, "ELG"))
2841     i = PUBKEY_ALGO_ELGAMAL_E;
2842   else
2843     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
2844
2845   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2846     i = 0; /* we don't want to allow generation of these algorithms */
2847   return i;
2848 }
2849
2850 /*
2851  * Parse the usage parameter and set the keyflags.  Returns -1 on
2852  * error, 0 for no usage given or 1 for usage available.
2853  */
2854 static int
2855 parse_parameter_usage (const char *fname,
2856                        struct para_data_s *para, enum para_name key)
2857 {
2858     struct para_data_s *r = get_parameter( para, key );
2859     char *p, *pn;
2860     unsigned int use;
2861
2862     if( !r )
2863         return 0; /* none (this is an optional parameter)*/
2864
2865     use = 0;
2866     pn = r->u.value;
2867     while ( (p = strsep (&pn, " \t,")) ) {
2868         if ( !*p)
2869             ;
2870         else if ( !ascii_strcasecmp (p, "sign") )
2871             use |= PUBKEY_USAGE_SIG;
2872         else if ( !ascii_strcasecmp (p, "encrypt") )
2873             use |= PUBKEY_USAGE_ENC;
2874         else if ( !ascii_strcasecmp (p, "auth") )
2875             use |= PUBKEY_USAGE_AUTH;
2876         else {
2877             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2878             return -1; /* error */
2879         }
2880     }
2881     r->u.usage = use;
2882     return 1;
2883 }
2884
2885 static int
2886 parse_revocation_key (const char *fname,
2887                       struct para_data_s *para, enum para_name key)
2888 {
2889   struct para_data_s *r = get_parameter( para, key );
2890   struct revocation_key revkey;
2891   char *pn;
2892   int i;
2893
2894   if( !r )
2895     return 0; /* none (this is an optional parameter) */
2896
2897   pn = r->u.value;
2898
2899   revkey.class=0x80;
2900   revkey.algid=atoi(pn);
2901   if(!revkey.algid)
2902     goto fail;
2903
2904   /* Skip to the fpr */
2905   while(*pn && *pn!=':')
2906     pn++;
2907
2908   if(*pn!=':')
2909     goto fail;
2910
2911   pn++;
2912
2913   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2914     {
2915       int c=hextobyte(pn);
2916       if(c==-1)
2917         goto fail;
2918
2919       revkey.fpr[i]=c;
2920     }
2921
2922   /* skip to the tag */
2923   while(*pn && *pn!='s' && *pn!='S')
2924     pn++;
2925
2926   if(ascii_strcasecmp(pn,"sensitive")==0)
2927     revkey.class|=0x40;
2928
2929   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2930
2931   return 0;
2932
2933   fail:
2934   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2935   return -1; /* error */
2936 }
2937
2938
2939 static u32
2940 get_parameter_u32( struct para_data_s *para, enum para_name key )
2941 {
2942   struct para_data_s *r = get_parameter( para, key );
2943
2944   if( !r )
2945     return 0;
2946   if( r->key == pKEYCREATIONDATE )
2947     return r->u.creation;
2948   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2949     return r->u.expire;
2950   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2951     return r->u.usage;
2952
2953   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2954 }
2955
2956 static unsigned int
2957 get_parameter_uint( struct para_data_s *para, enum para_name key )
2958 {
2959     return get_parameter_u32( para, key );
2960 }
2961
2962 static struct revocation_key *
2963 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2964 {
2965     struct para_data_s *r = get_parameter( para, key );
2966     return r? &r->u.revkey : NULL;
2967 }
2968
2969 static int
2970 proc_parameter_file( struct para_data_s *para, const char *fname,
2971                      struct output_control_s *outctrl, int card )
2972 {
2973   struct para_data_s *r;
2974   const char *s1, *s2, *s3;
2975   size_t n;
2976   char *p;
2977   int is_default = 0;
2978   int have_user_id = 0;
2979   int err, algo;
2980
2981   /* Check that we have all required parameters. */
2982   r = get_parameter( para, pKEYTYPE );
2983   if(r)
2984     {
2985       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2986       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2987         {
2988           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2989           return -1;
2990         }
2991     }
2992   else
2993     {
2994       log_error ("%s: no Key-Type specified\n",fname);
2995       return -1;
2996     }
2997
2998   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2999   if (!err)
3000     {
3001       /* Default to algo capabilities if key-usage is not provided and
3002          no default algorithm has been requested.  */
3003       r = xmalloc_clear(sizeof(*r));
3004       r->key = pKEYUSAGE;
3005       r->u.usage = (is_default
3006                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
3007                     : openpgp_pk_algo_usage(algo));
3008       append_to_parameter (para, r);
3009     }
3010   else if (err == -1)
3011     return -1;
3012   else
3013     {
3014       r = get_parameter (para, pKEYUSAGE);
3015       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3016         {
3017           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
3018                      fname, r->lnr, algo);
3019           return -1;
3020         }
3021     }
3022
3023   is_default = 0;
3024   r = get_parameter( para, pSUBKEYTYPE );
3025   if(r)
3026     {
3027       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
3028       if (openpgp_pk_test_algo (algo))
3029         {
3030           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3031           return -1;
3032         }
3033
3034       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
3035       if (!err)
3036         {
3037           /* Default to algo capabilities if subkey-usage is not
3038              provided */
3039           r = xmalloc_clear (sizeof(*r));
3040           r->key = pSUBKEYUSAGE;
3041           r->u.usage = (is_default
3042                         ? PUBKEY_USAGE_ENC
3043                         : openpgp_pk_algo_usage (algo));
3044           append_to_parameter (para, r);
3045         }
3046       else if (err == -1)
3047         return -1;
3048       else
3049         {
3050           r = get_parameter (para, pSUBKEYUSAGE);
3051           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3052             {
3053               log_error ("%s:%d: specified Subkey-Usage not allowed"
3054                          " for algo %d\n", fname, r->lnr, algo);
3055               return -1;
3056             }
3057         }
3058     }
3059
3060
3061   if( get_parameter_value( para, pUSERID ) )
3062     have_user_id=1;
3063   else
3064     {
3065       /* create the formatted user ID */
3066       s1 = get_parameter_value( para, pNAMEREAL );
3067       s2 = get_parameter_value( para, pNAMECOMMENT );
3068       s3 = get_parameter_value( para, pNAMEEMAIL );
3069       if( s1 || s2 || s3 )
3070         {
3071           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
3072           r = xmalloc_clear( sizeof *r + n + 20 );
3073           r->key = pUSERID;
3074           p = r->u.value;
3075           if( s1 )
3076             p = stpcpy(p, s1 );
3077           if( s2 )
3078             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
3079           if( s3 )
3080             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
3081           append_to_parameter (para, r);
3082           have_user_id=1;
3083         }
3084     }
3085
3086   if(!have_user_id)
3087     {
3088       log_error("%s: no User-ID specified\n",fname);
3089       return -1;
3090     }
3091
3092   /* Set preferences, if any. */
3093   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
3094
3095   /* Set keyserver, if any. */
3096   s1=get_parameter_value( para, pKEYSERVER );
3097   if(s1)
3098     {
3099       struct keyserver_spec *spec;
3100
3101       spec=parse_keyserver_uri(s1,1,NULL,0);
3102       if(spec)
3103         {
3104           free_keyserver_spec(spec);
3105           opt.def_keyserver_url=s1;
3106         }
3107       else
3108         {
3109           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
3110           return -1;
3111         }
3112     }
3113
3114   /* Set revoker, if any. */
3115   if (parse_revocation_key (fname, para, pREVOKER))
3116     return -1;
3117
3118   /* Make DEK and S2K from the Passphrase. */
3119   if (outctrl->ask_passphrase)
3120     {
3121       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
3122          feature is required so that GUIs are able to do a key
3123          creation but have gpg-agent ask for the passphrase.  */
3124       int canceled = 0;
3125       STRING2KEY *s2k;
3126       DEK *dek;
3127
3128       dek = do_ask_passphrase (&s2k, 0, &canceled);
3129       if (dek)
3130         {
3131           r = xmalloc_clear( sizeof *r );
3132           r->key = pPASSPHRASE_DEK;
3133           r->u.dek = dek;
3134           append_to_parameter (para, r);
3135           r = xmalloc_clear( sizeof *r );
3136           r->key = pPASSPHRASE_S2K;
3137           r->u.s2k = s2k;
3138           append_to_parameter (para, r);
3139         }
3140
3141       if (canceled)
3142         {
3143           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
3144           return -1;
3145         }
3146     }
3147   else
3148     {
3149       r = get_parameter( para, pPASSPHRASE );
3150       if ( r && *r->u.value )
3151         {
3152           /* We have a plain text passphrase - create a DEK from it.
3153            * It is a little bit ridiculous to keep it in secure memory
3154            * but because we do this always, why not here.  */
3155           STRING2KEY *s2k;
3156           DEK *dek;
3157
3158           s2k = xmalloc ( sizeof *s2k );
3159           s2k->mode = opt.s2k_mode;
3160           s2k->hash_algo = S2K_DIGEST_ALGO;
3161           set_next_passphrase ( r->u.value );
3162           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3163                                    NULL, NULL);
3164           if (!dek)
3165             {
3166               log_error ("%s:%d: error post processing the passphrase\n",
3167                          fname, r->lnr );
3168               xfree (s2k);
3169               return -1;
3170             }
3171           set_next_passphrase (NULL);
3172           memset (r->u.value, 0, strlen(r->u.value));
3173
3174           r = xmalloc_clear (sizeof *r);
3175           r->key = pPASSPHRASE_S2K;
3176           r->u.s2k = s2k;
3177           append_to_parameter (para, r);
3178           r = xmalloc_clear (sizeof *r);
3179           r->key = pPASSPHRASE_DEK;
3180           r->u.dek = dek;
3181           append_to_parameter (para, r);
3182         }
3183     }
3184
3185   /* Make KEYCREATIONDATE from Creation-Date.  */
3186   r = get_parameter (para, pCREATIONDATE);
3187   if (r && *r->u.value)
3188     {
3189       u32 seconds;
3190
3191       seconds = parse_creation_string (r->u.value);
3192       if (!seconds)
3193         {
3194           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
3195           return -1;
3196         }
3197       r->u.creation = seconds;
3198       r->key = pKEYCREATIONDATE;  /* Change that entry. */
3199     }
3200
3201   /* Make KEYEXPIRE from Expire-Date.  */
3202   r = get_parameter( para, pEXPIREDATE );
3203   if( r && *r->u.value )
3204     {
3205       u32 seconds;
3206
3207       seconds = parse_expire_string( r->u.value );
3208       if( seconds == (u32)-1 )
3209         {
3210           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
3211           return -1;
3212         }
3213       r->u.expire = seconds;
3214       r->key = pKEYEXPIRE;  /* change hat entry */
3215       /* also set it for the subkey */
3216       r = xmalloc_clear( sizeof *r + 20 );
3217       r->key = pSUBKEYEXPIRE;
3218       r->u.expire = seconds;
3219       append_to_parameter (para, r);
3220     }
3221
3222   do_generate_keypair( para, outctrl, card );
3223   return 0;
3224 }
3225
3226
3227 /****************
3228  * Kludge to allow non interactive key generation controlled
3229  * by a parameter file.
3230  * Note, that string parameters are expected to be in UTF-8
3231  */
3232 static void
3233 read_parameter_file( const char *fname )
3234 {
3235     static struct { const char *name;
3236                     enum para_name key;
3237     } keywords[] = {
3238         { "Key-Type",       pKEYTYPE},
3239         { "Key-Length",     pKEYLENGTH },
3240         { "Key-Curve",      pKEYCURVE },
3241         { "Key-Usage",      pKEYUSAGE },
3242         { "Subkey-Type",    pSUBKEYTYPE },
3243         { "Subkey-Length",  pSUBKEYLENGTH },
3244         { "Subkey-Curve",   pSUBKEYCURVE },
3245         { "Subkey-Usage",   pSUBKEYUSAGE },
3246         { "Name-Real",      pNAMEREAL },
3247         { "Name-Email",     pNAMEEMAIL },
3248         { "Name-Comment",   pNAMECOMMENT },
3249         { "Expire-Date",    pEXPIREDATE },
3250         { "Creation-Date",  pCREATIONDATE },
3251         { "Passphrase",     pPASSPHRASE },
3252         { "Preferences",    pPREFERENCES },
3253         { "Revoker",        pREVOKER },
3254         { "Handle",         pHANDLE },
3255         { "Keyserver",      pKEYSERVER },
3256         { NULL, 0 }
3257     };
3258     IOBUF fp;
3259     byte *line;
3260     unsigned int maxlen, nline;
3261     char *p;
3262     int lnr;
3263     const char *err = NULL;
3264     struct para_data_s *para, *r;
3265     int i;
3266     struct output_control_s outctrl;
3267
3268     memset( &outctrl, 0, sizeof( outctrl ) );
3269     outctrl.pub.afx = new_armor_context ();
3270
3271     if( !fname || !*fname)
3272       fname = "-";
3273
3274     fp = iobuf_open (fname);
3275     if (fp && is_secured_file (iobuf_get_fd (fp)))
3276       {
3277         iobuf_close (fp);
3278         fp = NULL;
3279         gpg_err_set_errno (EPERM);
3280       }
3281     if (!fp) {
3282       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
3283       return;
3284     }
3285     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
3286
3287     lnr = 0;
3288     err = NULL;
3289     para = NULL;
3290     maxlen = 1024;
3291     line = NULL;
3292     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
3293         char *keyword, *value;
3294
3295         lnr++;
3296         if( !maxlen ) {
3297             err = "line too long";
3298             break;
3299         }
3300         for( p = line; isspace(*(byte*)p); p++ )
3301             ;
3302         if( !*p || *p == '#' )
3303             continue;
3304         keyword = p;
3305         if( *keyword == '%' ) {
3306             for( ; !isspace(*(byte*)p); p++ )
3307                 ;
3308             if( *p )
3309                 *p++ = 0;
3310             for( ; isspace(*(byte*)p); p++ )
3311                 ;
3312             value = p;
3313             trim_trailing_ws( value, strlen(value) );
3314             if( !ascii_strcasecmp( keyword, "%echo" ) )
3315                 log_info("%s\n", value );
3316             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
3317                 outctrl.dryrun = 1;
3318             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
3319                 outctrl.ask_passphrase = 1;
3320             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
3321                 outctrl.ask_passphrase = 0;
3322             else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
3323                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
3324             else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
3325                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
3326             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
3327                 outctrl.lnr = lnr;
3328                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
3329                   print_status_key_not_created
3330                     (get_parameter_value (para, pHANDLE));
3331                 release_parameter_list( para );
3332                 para = NULL;
3333             }
3334             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
3335                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
3336                     ; /* still the same file - ignore it */
3337                 else {
3338                     xfree( outctrl.pub.newfname );
3339                     outctrl.pub.newfname = xstrdup( value );
3340                     outctrl.use_files = 1;
3341                 }
3342             }
3343             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
3344               /* Ignore this command.  */
3345             }
3346             else
3347                 log_info("skipping control '%s' (%s)\n", keyword, value );
3348
3349
3350             continue;
3351         }
3352
3353
3354         if( !(p = strchr( p, ':' )) || p == keyword ) {
3355             err = "missing colon";
3356             break;
3357         }
3358         if( *p )
3359             *p++ = 0;
3360         for( ; isspace(*(byte*)p); p++ )
3361             ;
3362         if( !*p ) {
3363             err = "missing argument";
3364             break;
3365         }
3366         value = p;
3367         trim_trailing_ws( value, strlen(value) );
3368
3369         for(i=0; keywords[i].name; i++ ) {
3370             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
3371                 break;
3372         }
3373         if( !keywords[i].name ) {
3374             err = "unknown keyword";
3375             break;
3376         }
3377         if( keywords[i].key != pKEYTYPE && !para ) {
3378             err = "parameter block does not start with \"Key-Type\"";
3379             break;
3380         }
3381
3382         if( keywords[i].key == pKEYTYPE && para ) {
3383             outctrl.lnr = lnr;
3384             if (proc_parameter_file( para, fname, &outctrl, 0 ))
3385               print_status_key_not_created
3386                 (get_parameter_value (para, pHANDLE));
3387             release_parameter_list( para );
3388             para = NULL;
3389         }
3390         else {
3391             for( r = para; r; r = r->next ) {
3392                 if( r->key == keywords[i].key )
3393                     break;
3394             }
3395             if( r ) {
3396                 err = "duplicate keyword";
3397                 break;
3398             }
3399         }
3400         r = xmalloc_clear( sizeof *r + strlen( value ) );
3401         r->lnr = lnr;
3402         r->key = keywords[i].key;
3403         strcpy( r->u.value, value );
3404         r->next = para;
3405         para = r;
3406     }
3407     if( err )
3408         log_error("%s:%d: %s\n", fname, lnr, err );
3409     else if( iobuf_error (fp) ) {
3410         log_error("%s:%d: read error\n", fname, lnr);
3411     }
3412     else if( para ) {
3413         outctrl.lnr = lnr;
3414         if (proc_parameter_file( para, fname, &outctrl, 0 ))
3415           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3416     }
3417
3418     if( outctrl.use_files ) { /* close open streams */
3419         iobuf_close( outctrl.pub.stream );
3420
3421         /* Must invalidate that ugly cache to actually close it.  */
3422         if (outctrl.pub.fname)
3423           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3424                        0, (char*)outctrl.pub.fname);
3425
3426         xfree( outctrl.pub.fname );
3427         xfree( outctrl.pub.newfname );
3428     }
3429
3430     release_parameter_list( para );
3431     iobuf_close (fp);
3432     release_armor_context (outctrl.pub.afx);
3433 }
3434
3435
3436 /* Helper for quick_generate_keypair.  */
3437 static struct para_data_s *
3438 quickgen_set_para (struct para_data_s *para, int for_subkey,
3439                    int algo, int nbits, const char *curve)
3440 {
3441   struct para_data_s *r;
3442
3443   r = xmalloc_clear (sizeof *r + 20);
3444   r->key = for_subkey? pSUBKEYUSAGE :  pKEYUSAGE;
3445   strcpy (r->u.value, for_subkey ? "encrypt" : "sign");
3446   r->next = para;
3447   para = r;
3448   r = xmalloc_clear (sizeof *r + 20);
3449   r->key = for_subkey? pSUBKEYTYPE : pKEYTYPE;
3450   sprintf (r->u.value, "%d", algo);
3451   r->next = para;
3452   para = r;
3453
3454   if (curve)
3455     {
3456       r = xmalloc_clear (sizeof *r + strlen (curve));
3457       r->key = for_subkey? pSUBKEYCURVE : pKEYCURVE;
3458       strcpy (r->u.value, curve);
3459       r->next = para;
3460       para = r;
3461     }
3462   else
3463     {
3464       r = xmalloc_clear (sizeof *r + 20);
3465       r->key = for_subkey? pSUBKEYLENGTH : pKEYLENGTH;
3466       sprintf (r->u.value, "%u", nbits);
3467       r->next = para;
3468       para = r;
3469     }
3470
3471   return para;
3472 }
3473
3474
3475 /*
3476  * Unattended generation of a standard key.
3477  */
3478 void
3479 quick_generate_keypair (const char *uid)
3480 {
3481   gpg_error_t err;
3482   struct para_data_s *para = NULL;
3483   struct para_data_s *r;
3484   struct output_control_s outctrl;
3485   int use_tty;
3486
3487   memset (&outctrl, 0, sizeof outctrl);
3488
3489   use_tty = (!opt.batch && !opt.answer_yes
3490              && !cpr_enabled ()
3491              && gnupg_isatty (fileno (stdin))
3492              && gnupg_isatty (fileno (stdout))
3493              && gnupg_isatty (fileno (stderr)));
3494
3495   r = xmalloc_clear (sizeof *r + strlen (uid));
3496   r->key = pUSERID;
3497   strcpy (r->u.value, uid);
3498   r->next = para;
3499   para = r;
3500
3501   uid = trim_spaces (r->u.value);
3502   if (!*uid || (!opt.allow_freeform_uid && !is_valid_user_id (uid)))
3503     {
3504       log_error (_("Key generation failed: %s\n"),
3505                  gpg_strerror (GPG_ERR_INV_USER_ID));
3506       goto leave;
3507     }
3508
3509   /* If gpg is directly used on the console ask whether a key with the
3510      given user id shall really be created.  */
3511   if (use_tty)
3512     {
3513       tty_printf (_("About to create a key for:\n    \"%s\"\n\n"), uid);
3514       if (!cpr_get_answer_is_yes_def ("quick_keygen.okay",
3515                                       _("Continue? (Y/n) "), 1))
3516         goto leave;
3517     }
3518
3519   /* Check whether such a user ID already exists.  */
3520   {
3521     KEYDB_HANDLE kdbhd;
3522     KEYDB_SEARCH_DESC desc;
3523
3524     memset (&desc, 0, sizeof desc);
3525     desc.mode = KEYDB_SEARCH_MODE_EXACT;
3526     desc.u.name = uid;
3527
3528     kdbhd = keydb_new ();
3529     err = keydb_search (kdbhd, &desc, 1, NULL);
3530     keydb_release (kdbhd);
3531     if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
3532       {
3533         log_info (_("A key for \"%s\" already exists\n"), uid);
3534         if (opt.answer_yes)
3535           ;
3536         else if (!use_tty
3537                  || !cpr_get_answer_is_yes_def ("quick_keygen.force",
3538                                                 _("Create anyway? (y/N) "), 0))
3539           {
3540             log_inc_errorcount ();  /* we used log_info */
3541             goto leave;
3542           }
3543         log_info (_("creating anyway\n"));
3544       }
3545   }
3546
3547   para = quickgen_set_para (para, 0,
3548                             DEFAULT_STD_ALGO, DEFAULT_STD_KEYSIZE,
3549                             DEFAULT_STD_CURVE);
3550   para = quickgen_set_para (para, 1,
3551                             DEFAULT_STD_SUBALGO, DEFAULT_STD_SUBKEYSIZE,
3552                             DEFAULT_STD_SUBCURVE);
3553
3554   proc_parameter_file (para, "[internal]", &outctrl, 0);
3555  leave:
3556   release_parameter_list (para);
3557 }
3558
3559
3560 /*
3561  * Generate a keypair (fname is only used in batch mode) If
3562  * CARD_SERIALNO is not NULL the function will create the keys on an
3563  * OpenPGP Card.  If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
3564  * NOT NULL, the encryption key for the card is generated on the host,
3565  * imported to the card and a backup file created by gpg-agent.  If
3566  * FULL is not set only the basic prompts are used (except for batch
3567  * mode).
3568  */
3569 void
3570 generate_keypair (ctrl_t ctrl, int full, const char *fname,
3571                   const char *card_serialno, int card_backup_key)
3572 {
3573   unsigned int nbits;
3574   char *uid = NULL;
3575   int algo;
3576   unsigned int use;
3577   int both = 0;
3578   u32 expire;
3579   struct para_data_s *para = NULL;
3580   struct para_data_s *r;
3581   struct output_control_s outctrl;
3582
3583 #ifndef ENABLE_CARD_SUPPORT
3584   (void)card_backup_key;
3585 #endif
3586
3587   memset( &outctrl, 0, sizeof( outctrl ) );
3588
3589   if (opt.batch && card_serialno)
3590     {
3591       /* We don't yet support unattended key generation. */
3592       log_error (_("can't do this in batch mode\n"));
3593       return;
3594     }
3595
3596   if (opt.batch)
3597     {
3598       read_parameter_file( fname );
3599       return;
3600     }
3601
3602   if (card_serialno)
3603     {
3604 #ifdef ENABLE_CARD_SUPPORT
3605       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3606       r->key = pSERIALNO;
3607       strcpy( r->u.value, card_serialno);
3608       r->next = para;
3609       para = r;
3610
3611       algo = PUBKEY_ALGO_RSA;
3612
3613       r = xcalloc (1, sizeof *r + 20 );
3614       r->key = pKEYTYPE;
3615       sprintf( r->u.value, "%d", algo );
3616       r->next = para;
3617       para = r;
3618       r = xcalloc (1, sizeof *r + 20 );
3619       r->key = pKEYUSAGE;
3620       strcpy (r->u.value, "sign");
3621       r->next = para;
3622       para = r;
3623
3624       r = xcalloc (1, sizeof *r + 20 );
3625       r->key = pSUBKEYTYPE;
3626       sprintf( r->u.value, "%d", algo );
3627       r->next = para;
3628       para = r;
3629       r = xcalloc (1, sizeof *r + 20 );
3630       r->key = pSUBKEYUSAGE;
3631       strcpy (r->u.value, "encrypt");
3632       r->next = para;
3633       para = r;
3634
3635       r = xcalloc (1, sizeof *r + 20 );
3636       r->key = pAUTHKEYTYPE;
3637       sprintf( r->u.value, "%d", algo );
3638       r->next = para;
3639       para = r;
3640
3641       if (card_backup_key)
3642         {
3643           r = xcalloc (1, sizeof *r + 1);
3644           r->key = pCARDBACKUPKEY;
3645           strcpy (r->u.value, "1");
3646           r->next = para;
3647           para = r;
3648         }
3649 #endif /*ENABLE_CARD_SUPPORT*/
3650     }
3651   else if (full)  /* Full featured key generation.  */
3652     {
3653       int subkey_algo;
3654       char *curve = NULL;
3655
3656       /* Fixme: To support creating a primary key by keygrip we better
3657          also define the keyword for the parameter file.  Note that
3658          the subkey case will never be asserted if a keygrip has been
3659          given.  */
3660       algo = ask_algo (ctrl, 0, &subkey_algo, &use, NULL);
3661       if (subkey_algo)
3662         {
3663           /* Create primary and subkey at once.  */
3664           both = 1;
3665           if (algo == PUBKEY_ALGO_ECDSA
3666               || algo == PUBKEY_ALGO_EDDSA
3667               || algo == PUBKEY_ALGO_ECDH)
3668             {
3669               curve = ask_curve (&algo, both);
3670               r = xmalloc_clear( sizeof *r + 20 );
3671               r->key = pKEYTYPE;
3672               sprintf( r->u.value, "%d", algo);
3673               r->next = para;
3674               para = r;
3675               nbits = 0;
3676               r = xmalloc_clear (sizeof *r + strlen (curve));
3677               r->key = pKEYCURVE;
3678               strcpy (r->u.value, curve);
3679               r->next = para;
3680               para = r;
3681             }
3682           else
3683             {
3684               r = xmalloc_clear( sizeof *r + 20 );
3685               r->key = pKEYTYPE;
3686               sprintf( r->u.value, "%d", algo);
3687               r->next = para;
3688               para = r;
3689               nbits = ask_keysize (algo, 0);
3690               r = xmalloc_clear( sizeof *r + 20 );
3691               r->key = pKEYLENGTH;
3692               sprintf( r->u.value, "%u", nbits);
3693               r->next = para;
3694               para = r;
3695             }
3696           r = xmalloc_clear( sizeof *r + 20 );
3697           r->key = pKEYUSAGE;
3698           strcpy( r->u.value, "sign" );
3699           r->next = para;
3700           para = r;
3701
3702           r = xmalloc_clear( sizeof *r + 20 );
3703           r->key = pSUBKEYTYPE;
3704           sprintf( r->u.value, "%d", subkey_algo);
3705           r->next = para;
3706           para = r;
3707           r = xmalloc_clear( sizeof *r + 20 );
3708           r->key = pSUBKEYUSAGE;
3709           strcpy( r->u.value, "encrypt" );
3710           r->next = para;
3711           para = r;
3712
3713           if (algo == PUBKEY_ALGO_ECDSA
3714               || algo == PUBKEY_ALGO_EDDSA
3715               || algo == PUBKEY_ALGO_ECDH)
3716             {
3717               if (algo == PUBKEY_ALGO_EDDSA
3718                   && subkey_algo == PUBKEY_ALGO_ECDH)
3719                 {
3720                   /* Need to switch to a different curve for the
3721                      encryption key.  */
3722                   xfree (curve);
3723                   curve = xstrdup ("Curve25519");
3724                 }
3725               r = xmalloc_clear (sizeof *r + strlen (curve));
3726               r->key = pSUBKEYCURVE;
3727               strcpy (r->u.value, curve);
3728               r->next = para;
3729               para = r;
3730             }
3731         }
3732       else /* Create only a single key.  */
3733         {
3734           /* For ECC we need to ask for the curve before storing the
3735              algo because ask_curve may change the algo.  */
3736           if (algo == PUBKEY_ALGO_ECDSA
3737               || algo == PUBKEY_ALGO_EDDSA
3738               || algo == PUBKEY_ALGO_ECDH)
3739             {
3740               curve = ask_curve (&algo, 0);
3741               nbits = 0;
3742               r = xmalloc_clear (sizeof *r + strlen (curve));
3743               r->key = pKEYCURVE;
3744               strcpy (r->u.value, curve);
3745               r->next = para;
3746               para = r;
3747             }
3748
3749           r = xmalloc_clear( sizeof *r + 20 );
3750           r->key = pKEYTYPE;
3751           sprintf( r->u.value, "%d", algo );
3752           r->next = para;
3753           para = r;
3754
3755           if (use)
3756             {
3757               r = xmalloc_clear( sizeof *r + 25 );
3758               r->key = pKEYUSAGE;
3759               sprintf( r->u.value, "%s%s%s",
3760                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3761                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3762                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3763               r->next = para;
3764               para = r;
3765             }
3766           nbits = 0;
3767         }
3768
3769       if (algo == PUBKEY_ALGO_ECDSA
3770           || algo == PUBKEY_ALGO_EDDSA
3771           || algo == PUBKEY_ALGO_ECDH)
3772         {
3773           /* The curve has already been set.  */
3774         }
3775       else
3776         {
3777           nbits = ask_keysize (both? subkey_algo : algo, nbits);
3778           r = xmalloc_clear( sizeof *r + 20 );
3779           r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3780           sprintf( r->u.value, "%u", nbits);
3781           r->next = para;
3782           para = r;
3783         }
3784
3785       xfree (curve);
3786     }
3787   else /* Default key generation.  */
3788     {
3789       tty_printf ( _("Note: Use \"%s %s\""
3790                      " for a full featured key generation dialog.\n"),
3791                    GPG_NAME, "--full-gen-key" );
3792       para = quickgen_set_para (para, 0,
3793                                 DEFAULT_STD_ALGO, DEFAULT_STD_KEYSIZE,
3794                                 DEFAULT_STD_CURVE);
3795       para = quickgen_set_para (para, 1,
3796                                 DEFAULT_STD_SUBALGO, DEFAULT_STD_SUBKEYSIZE,
3797                                 DEFAULT_STD_SUBCURVE);
3798     }
3799
3800
3801   expire = full? ask_expire_interval (0, NULL) : 0;
3802   r = xcalloc (1, sizeof *r + 20);
3803   r->key = pKEYEXPIRE;
3804   r->u.expire = expire;
3805   r->next = para;
3806   para = r;
3807   r = xcalloc (1, sizeof *r + 20);
3808   r->key = pSUBKEYEXPIRE;
3809   r->u.expire = expire;
3810   r->next = para;
3811   para = r;
3812
3813   uid = ask_user_id (0, full, NULL);
3814   if (!uid)
3815     {
3816       log_error(_("Key generation canceled.\n"));
3817       release_parameter_list( para );
3818       return;
3819     }
3820   r = xcalloc (1, sizeof *r + strlen (uid));
3821   r->key = pUSERID;
3822   strcpy (r->u.value, uid);
3823   r->next = para;
3824   para = r;
3825
3826   proc_parameter_file (para, "[internal]", &outctrl, !!card_serialno);
3827   release_parameter_list (para);
3828 }
3829
3830
3831 #if 0 /* not required */
3832 /* Generate a raw key and return it as a secret key packet.  The
3833    function will ask for the passphrase and return a protected as well
3834    as an unprotected copy of a new secret key packet.  0 is returned
3835    on success and the caller must then free the returned values.  */
3836 static int
3837 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3838                   PKT_secret_key **r_sk_unprotected,
3839                   PKT_secret_key **r_sk_protected)
3840 {
3841   int rc;
3842   DEK *dek = NULL;
3843   STRING2KEY *s2k = NULL;
3844   PKT_secret_key *sk = NULL;
3845   int i;
3846   size_t nskey, npkey;
3847   gcry_sexp_t s_parms, s_key;
3848   int canceled;
3849
3850   npkey = pubkey_get_npkey (algo);
3851   nskey = pubkey_get_nskey (algo);
3852   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3853
3854   if (nbits < 512)
3855     {
3856       nbits = 512;
3857       log_info (_("keysize invalid; using %u bits\n"), nbits );
3858     }
3859
3860   if ((nbits % 32))
3861     {
3862       nbits = ((nbits + 31) / 32) * 32;
3863       log_info(_("keysize rounded up to %u bits\n"), nbits );
3864     }
3865
3866   dek = do_ask_passphrase (&s2k, 1, &canceled);
3867   if (canceled)
3868     {
3869       rc = gpg_error (GPG_ERR_CANCELED);
3870       goto leave;
3871     }
3872
3873   sk = xmalloc_clear (sizeof *sk);
3874   sk->timestamp = created_at;
3875   sk->version = 4;
3876   sk->pubkey_algo = algo;
3877
3878   if ( !is_RSA (algo) )
3879     {
3880       log_error ("only RSA is supported for offline generated keys\n");
3881       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3882       goto leave;
3883     }
3884   rc = gcry_sexp_build (&s_parms, NULL,
3885                         "(genkey(rsa(nbits %d)))",
3886                         (int)nbits);
3887   if (rc)
3888     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3889   rc = gcry_pk_genkey (&s_key, s_parms);
3890   gcry_sexp_release (s_parms);
3891   if (rc)
3892     {
3893       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3894       goto leave;
3895     }
3896   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3897   gcry_sexp_release (s_key);
3898   if (rc)
3899     {
3900       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3901       goto leave;
3902     }
3903
3904   for (i=npkey; i < nskey; i++)
3905     sk->csum += checksum_mpi (sk->skey[i]);
3906
3907   if (r_sk_unprotected)
3908     *r_sk_unprotected = copy_secret_key (NULL, sk);
3909
3910   rc = genhelp_protect (dek, s2k, sk);
3911   if (rc)
3912     goto leave;
3913
3914   if (r_sk_protected)
3915     {
3916       *r_sk_protected = sk;
3917       sk = NULL;
3918     }
3919
3920  leave:
3921   if (sk)
3922     free_secret_key (sk);
3923   xfree (dek);
3924   xfree (s2k);
3925   return rc;
3926 }
3927 #endif /* ENABLE_CARD_SUPPORT */
3928
3929 /* Create and delete a dummy packet to start off a list of kbnodes. */
3930 static void
3931 start_tree(KBNODE *tree)
3932 {
3933   PACKET *pkt;
3934
3935   pkt=xmalloc_clear(sizeof(*pkt));
3936   pkt->pkttype=PKT_NONE;
3937   *tree=new_kbnode(pkt);
3938   delete_kbnode(*tree);
3939 }
3940
3941
3942 static void
3943 do_generate_keypair (struct para_data_s *para,
3944                      struct output_control_s *outctrl, int card)
3945 {
3946   gpg_error_t err;
3947   KBNODE pub_root = NULL;
3948   const char *s;
3949   PKT_public_key *pri_psk = NULL;
3950   PKT_public_key *sub_psk = NULL;
3951   struct revocation_key *revkey;
3952   int did_sub = 0;
3953   u32 timestamp;
3954   char *cache_nonce = NULL;
3955
3956   if (outctrl->dryrun)
3957     {
3958       log_info("dry-run mode - key generation skipped\n");
3959       return;
3960     }
3961
3962   if ( outctrl->use_files )
3963     {
3964       if ( outctrl->pub.newfname )
3965         {
3966           iobuf_close(outctrl->pub.stream);
3967           outctrl->pub.stream = NULL;
3968           if (outctrl->pub.fname)
3969             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3970                          0, (char*)outctrl->pub.fname);
3971           xfree( outctrl->pub.fname );
3972           outctrl->pub.fname =  outctrl->pub.newfname;
3973           outctrl->pub.newfname = NULL;
3974
3975           if (is_secured_filename (outctrl->pub.fname) )
3976             {
3977               outctrl->pub.stream = NULL;
3978               gpg_err_set_errno (EPERM);
3979             }
3980           else
3981             outctrl->pub.stream = iobuf_create (outctrl->pub.fname, 0);
3982           if (!outctrl->pub.stream)
3983             {
3984               log_error(_("can't create '%s': %s\n"), outctrl->pub.newfname,
3985                         strerror(errno) );
3986               return;
3987             }
3988           if (opt.armor)
3989             {
3990               outctrl->pub.afx->what = 1;
3991               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3992             }
3993         }
3994       assert( outctrl->pub.stream );
3995       if (opt.verbose)
3996         log_info (_("writing public key to '%s'\n"), outctrl->pub.fname );
3997     }
3998
3999
4000   /* We create the packets as a tree of kbnodes.  Because the
4001      structure we create is known in advance we simply generate a
4002      linked list.  The first packet is a dummy packet which we flag as
4003      deleted.  The very first packet must always be a KEY packet.  */
4004
4005   start_tree (&pub_root);
4006
4007   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
4008   if (!timestamp)
4009     timestamp = make_timestamp ();
4010
4011   /* Note that, depending on the backend (i.e. the used scdaemon
4012      version), the card key generation may update TIMESTAMP for each
4013      key.  Thus we need to pass TIMESTAMP to all signing function to
4014      make sure that the binding signature is done using the timestamp
4015      of the corresponding (sub)key and not that of the primary key.
4016      An alternative implementation could tell the signing function the
4017      node of the subkey but that is more work than just to pass the
4018      current timestamp.  */
4019
4020   if (!card)
4021     err = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
4022                      get_parameter_uint( para, pKEYLENGTH ),
4023                      get_parameter_value (para, pKEYCURVE),
4024                      pub_root,
4025                      timestamp,
4026                      get_parameter_u32( para, pKEYEXPIRE ), 0,
4027                      outctrl->keygen_flags, &cache_nonce);
4028   else
4029     err = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root,
4030                         &timestamp,
4031                         get_parameter_u32 (para, pKEYEXPIRE));
4032
4033   /* Get the pointer to the generated public key packet.  */
4034   if (!err)
4035     {
4036       pri_psk = pub_root->next->pkt->pkt.public_key;
4037       assert (pri_psk);
4038     }
4039
4040   if (!err && (revkey = get_parameter_revkey (para, pREVOKER)))
4041     err = write_direct_sig (pub_root, pri_psk, revkey, timestamp, cache_nonce);
4042
4043   if (!err && (s = get_parameter_value (para, pUSERID)))
4044     {
4045       write_uid (pub_root, s );
4046       err = write_selfsigs (pub_root, pri_psk,
4047                             get_parameter_uint (para, pKEYUSAGE), timestamp,
4048                             cache_nonce);
4049     }
4050
4051   /* Write the auth key to the card before the encryption key.  This
4052      is a partial workaround for a PGP bug (as of this writing, all
4053      versions including 8.1), that causes it to try and encrypt to
4054      the most recent subkey regardless of whether that subkey is
4055      actually an encryption type.  In this case, the auth key is an
4056      RSA key so it succeeds. */
4057
4058   if (!err && card && get_parameter (para, pAUTHKEYTYPE))
4059     {
4060       err = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root,
4061                           &timestamp,
4062                           get_parameter_u32 (para, pKEYEXPIRE));
4063       if (!err)
4064         err = write_keybinding (pub_root, pri_psk, NULL,
4065                                 PUBKEY_USAGE_AUTH, timestamp, cache_nonce);
4066     }
4067
4068   if (!err && get_parameter (para, pSUBKEYTYPE))
4069     {
4070       sub_psk = NULL;
4071       if (!card)
4072         {
4073           err = do_create (get_parameter_algo (para, pSUBKEYTYPE, NULL),
4074                            get_parameter_uint (para, pSUBKEYLENGTH),
4075                            get_parameter_value (para, pSUBKEYCURVE),
4076                            pub_root,
4077                            timestamp,
4078                            get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
4079                            outctrl->keygen_flags, &cache_nonce);
4080           /* Get the pointer to the generated public subkey packet.  */
4081           if (!err)
4082             {
4083               kbnode_t node;
4084
4085               for (node = pub_root; node; node = node->next)
4086                 if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
4087                   sub_psk = node->pkt->pkt.public_key;
4088               assert (sub_psk);
4089             }
4090         }
4091       else
4092         {
4093           if ((s = get_parameter_value (para, pCARDBACKUPKEY)))
4094             {
4095               /* A backup of the encryption key has been requested.
4096                  Generate the key in software and import it then to
4097                  the card.  Write a backup file. */
4098               err = gen_card_key_with_backup
4099                 (PUBKEY_ALGO_RSA, 2, 0, pub_root, timestamp,
4100                  get_parameter_u32 (para, pKEYEXPIRE), para);
4101             }
4102           else
4103             {
4104               err = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root,
4105                                   &timestamp,
4106                                   get_parameter_u32 (para, pKEYEXPIRE));
4107             }
4108         }
4109
4110       if (!err)
4111         err = write_keybinding (pub_root, pri_psk, sub_psk,
4112                                 get_parameter_uint (para, pSUBKEYUSAGE),
4113                                 timestamp, cache_nonce);
4114       did_sub = 1;
4115     }
4116
4117   if (!err && outctrl->use_files)  /* Direct write to specified files.  */
4118     {
4119       err = write_keyblock (outctrl->pub.stream, pub_root);
4120       if (err)
4121         log_error ("can't write public key: %s\n", g10_errstr (err));
4122     }
4123   else if (!err) /* Write to the standard keyrings.  */
4124     {
4125       KEYDB_HANDLE pub_hd = keydb_new ();
4126
4127       err = keydb_locate_writable (pub_hd, NULL);
4128       if (err)
4129         log_error (_("no writable public keyring found: %s\n"),
4130                    g10_errstr (err));
4131
4132       if (!err && opt.verbose)
4133         {
4134           log_info (_("writing public key to '%s'\n"),
4135                     keydb_get_resource_name (pub_hd));
4136         }
4137
4138       if (!err)
4139         {
4140           err = keydb_insert_keyblock (pub_hd, pub_root);
4141           if (err)
4142             log_error (_("error writing public keyring '%s': %s\n"),
4143                        keydb_get_resource_name (pub_hd), g10_errstr(err));
4144         }
4145
4146       keydb_release (pub_hd);
4147
4148       if (!err)
4149         {
4150           int no_enc_rsa;
4151           PKT_public_key *pk;
4152
4153           no_enc_rsa = ((get_parameter_algo (para, pKEYTYPE, NULL)
4154                          == PUBKEY_ALGO_RSA)
4155                         && get_parameter_uint (para, pKEYUSAGE)
4156                         && !((get_parameter_uint (para, pKEYUSAGE)
4157                               & PUBKEY_USAGE_ENC)) );
4158
4159           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
4160
4161           keyid_from_pk (pk, pk->main_keyid);
4162           register_trusted_keyid (pk->main_keyid);
4163
4164           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
4165                                   | TRUST_ULTIMATE ));
4166
4167           gen_standard_revoke (pk, cache_nonce);
4168
4169           if (!opt.batch)
4170             {
4171               tty_printf (_("public and secret key created and signed.\n") );
4172               tty_printf ("\n");
4173               list_keyblock (pub_root, 0, 1, 1, NULL);
4174             }
4175
4176
4177           if (!opt.batch
4178               && (get_parameter_algo (para, pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
4179                   || no_enc_rsa )
4180               && !get_parameter (para, pSUBKEYTYPE) )
4181             {
4182               tty_printf(_("Note that this key cannot be used for "
4183                            "encryption.  You may want to use\n"
4184                            "the command \"--edit-key\" to generate a "
4185                            "subkey for this purpose.\n") );
4186             }
4187         }
4188     }
4189
4190   if (err)
4191     {
4192       if (opt.batch)
4193         log_error ("key generation failed: %s\n", g10_errstr(err) );
4194       else
4195         tty_printf (_("Key generation failed: %s\n"), g10_errstr(err) );
4196       write_status_error (card? "card_key_generate":"key_generate", err);
4197       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
4198     }
4199   else
4200     {
4201       PKT_public_key *pk = find_kbnode (pub_root,
4202                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
4203       print_status_key_created (did_sub? 'B':'P', pk,
4204                                 get_parameter_value (para, pHANDLE));
4205     }
4206
4207   release_kbnode (pub_root);
4208   xfree (cache_nonce);
4209 }
4210
4211
4212 /* Add a new subkey to an existing key.  Returns 0 if a new key has
4213    been generated and put into the keyblocks.  */
4214 gpg_error_t
4215 generate_subkeypair (ctrl_t ctrl, kbnode_t keyblock)
4216 {
4217   gpg_error_t err = 0;
4218   kbnode_t node;
4219   PKT_public_key *pri_psk = NULL;
4220   PKT_public_key *sub_psk = NULL;
4221   int algo;
4222   unsigned int use;
4223   u32 expire;
4224   unsigned int nbits = 0;
4225   char *curve = NULL;
4226   u32 cur_time;
4227   char *hexgrip = NULL;
4228   char *serialno = NULL;
4229
4230   /* Break out the primary key.  */
4231   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
4232   if (!node)
4233     {
4234       log_error ("Oops; primary key missing in keyblock!\n");
4235       err = gpg_error (GPG_ERR_BUG);
4236       goto leave;
4237     }
4238   pri_psk = node->pkt->pkt.public_key;
4239
4240   cur_time = make_timestamp ();
4241
4242   if (pri_psk->timestamp > cur_time)
4243     {
4244       ulong d = pri_psk->timestamp - cur_time;
4245       log_info ( d==1 ? _("key has been created %lu second "
4246                           "in future (time warp or clock problem)\n")
4247                  : _("key has been created %lu seconds "
4248                      "in future (time warp or clock problem)\n"), d );
4249       if (!opt.ignore_time_conflict)
4250         {
4251           err = gpg_error (GPG_ERR_TIME_CONFLICT);
4252           goto leave;
4253         }
4254     }
4255
4256   if (pri_psk->version < 4)
4257     {
4258       log_info (_("NOTE: creating subkeys for v3 keys "
4259                   "is not OpenPGP compliant\n"));
4260       err = gpg_error (GPG_ERR_CONFLICT);
4261       goto leave;
4262     }
4263
4264   err = hexkeygrip_from_pk (pri_psk, &hexgrip);
4265   if (err)
4266     goto leave;
4267   if (agent_get_keyinfo (NULL, hexgrip, &serialno))
4268     {
4269       tty_printf (_("Secret parts of primary key are not available.\n"));
4270       goto leave;
4271     }
4272   if (serialno)
4273     tty_printf (_("Secret parts of primary key are stored on-card.\n"));
4274
4275   xfree (hexgrip);
4276   hexgrip = NULL;
4277   algo = ask_algo (ctrl, 1, NULL, &use, &hexgrip);
4278   assert (algo);
4279
4280   if (hexgrip)
4281