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