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