gpg: Fix a memory leak in batch key generation
[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 /* Append R to the linked list PARA.  */
2595 static void
2596 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
2597 {
2598   assert (para);
2599   while (para->next)
2600     para = para->next;
2601   para->next = r;
2602 }
2603
2604 /* Release the parameter list R.  */
2605 static void
2606 release_parameter_list (struct para_data_s *r)
2607 {
2608   struct para_data_s *r2;
2609
2610   for (; r ; r = r2)
2611     {
2612       r2 = r->next;
2613       if (r->key == pPASSPHRASE_DEK)
2614         xfree (r->u.dek);
2615       else if (r->key == pPASSPHRASE_S2K )
2616         xfree (r->u.s2k);
2617
2618       xfree (r);
2619     }
2620 }
2621
2622 static struct para_data_s *
2623 get_parameter( struct para_data_s *para, enum para_name key )
2624 {
2625     struct para_data_s *r;
2626
2627     for( r = para; r && r->key != key; r = r->next )
2628         ;
2629     return r;
2630 }
2631
2632 static const char *
2633 get_parameter_value( struct para_data_s *para, enum para_name key )
2634 {
2635     struct para_data_s *r = get_parameter( para, key );
2636     return (r && *r->u.value)? r->u.value : NULL;
2637 }
2638
2639 static int
2640 get_parameter_algo( struct para_data_s *para, enum para_name key,
2641                     int *r_default)
2642 {
2643   int i;
2644   struct para_data_s *r = get_parameter( para, key );
2645
2646   if (r_default)
2647     *r_default = 0;
2648
2649   if (!r)
2650     return -1;
2651
2652   if (!ascii_strcasecmp (r->u.value, "default"))
2653     {
2654       /* Note: If you change this default algo, remember to change it
2655          also in gpg.c:gpgconf_list.  */
2656       i = DEFAULT_STD_ALGO;
2657       if (r_default)
2658         *r_default = 1;
2659     }
2660   else if (digitp (r->u.value))
2661     i = atoi( r->u.value );
2662   else if (!strcmp (r->u.value, "ELG-E")
2663            || !strcmp (r->u.value, "ELG"))
2664     i = GCRY_PK_ELG_E;
2665   else
2666     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
2667
2668   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2669     i = 0; /* we don't want to allow generation of these algorithms */
2670   return i;
2671 }
2672
2673 /*
2674  * Parse the usage parameter and set the keyflags.  Returns -1 on
2675  * error, 0 for no usage given or 1 for usage available.
2676  */
2677 static int
2678 parse_parameter_usage (const char *fname,
2679                        struct para_data_s *para, enum para_name key)
2680 {
2681     struct para_data_s *r = get_parameter( para, key );
2682     char *p, *pn;
2683     unsigned int use;
2684
2685     if( !r )
2686         return 0; /* none (this is an optional parameter)*/
2687
2688     use = 0;
2689     pn = r->u.value;
2690     while ( (p = strsep (&pn, " \t,")) ) {
2691         if ( !*p)
2692             ;
2693         else if ( !ascii_strcasecmp (p, "sign") )
2694             use |= PUBKEY_USAGE_SIG;
2695         else if ( !ascii_strcasecmp (p, "encrypt") )
2696             use |= PUBKEY_USAGE_ENC;
2697         else if ( !ascii_strcasecmp (p, "auth") )
2698             use |= PUBKEY_USAGE_AUTH;
2699         else {
2700             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2701             return -1; /* error */
2702         }
2703     }
2704     r->u.usage = use;
2705     return 1;
2706 }
2707
2708 static int
2709 parse_revocation_key (const char *fname,
2710                       struct para_data_s *para, enum para_name key)
2711 {
2712   struct para_data_s *r = get_parameter( para, key );
2713   struct revocation_key revkey;
2714   char *pn;
2715   int i;
2716
2717   if( !r )
2718     return 0; /* none (this is an optional parameter) */
2719
2720   pn = r->u.value;
2721
2722   revkey.class=0x80;
2723   revkey.algid=atoi(pn);
2724   if(!revkey.algid)
2725     goto fail;
2726
2727   /* Skip to the fpr */
2728   while(*pn && *pn!=':')
2729     pn++;
2730
2731   if(*pn!=':')
2732     goto fail;
2733
2734   pn++;
2735
2736   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2737     {
2738       int c=hextobyte(pn);
2739       if(c==-1)
2740         goto fail;
2741
2742       revkey.fpr[i]=c;
2743     }
2744
2745   /* skip to the tag */
2746   while(*pn && *pn!='s' && *pn!='S')
2747     pn++;
2748
2749   if(ascii_strcasecmp(pn,"sensitive")==0)
2750     revkey.class|=0x40;
2751
2752   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2753
2754   return 0;
2755
2756   fail:
2757   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2758   return -1; /* error */
2759 }
2760
2761
2762 static u32
2763 get_parameter_u32( struct para_data_s *para, enum para_name key )
2764 {
2765   struct para_data_s *r = get_parameter( para, key );
2766
2767   if( !r )
2768     return 0;
2769   if( r->key == pKEYCREATIONDATE )
2770     return r->u.creation;
2771   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2772     return r->u.expire;
2773   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2774     return r->u.usage;
2775
2776   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2777 }
2778
2779 static unsigned int
2780 get_parameter_uint( struct para_data_s *para, enum para_name key )
2781 {
2782     return get_parameter_u32( para, key );
2783 }
2784
2785 static struct revocation_key *
2786 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2787 {
2788     struct para_data_s *r = get_parameter( para, key );
2789     return r? &r->u.revkey : NULL;
2790 }
2791
2792 static int
2793 proc_parameter_file( struct para_data_s *para, const char *fname,
2794                      struct output_control_s *outctrl, int card )
2795 {
2796   struct para_data_s *r;
2797   const char *s1, *s2, *s3;
2798   size_t n;
2799   char *p;
2800   int is_default = 0;
2801   int have_user_id = 0;
2802   int err, algo;
2803
2804   /* Check that we have all required parameters. */
2805   r = get_parameter( para, pKEYTYPE );
2806   if(r)
2807     {
2808       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2809       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2810         {
2811           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2812           return -1;
2813         }
2814     }
2815   else
2816     {
2817       log_error ("%s: no Key-Type specified\n",fname);
2818       return -1;
2819     }
2820
2821   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2822   if (!err)
2823     {
2824       /* Default to algo capabilities if key-usage is not provided and
2825          no default algorithm has been requested.  */
2826       r = xmalloc_clear(sizeof(*r));
2827       r->key = pKEYUSAGE;
2828       r->u.usage = (is_default
2829                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
2830                     : openpgp_pk_algo_usage(algo));
2831       append_to_parameter (para, r);
2832     }
2833   else if (err == -1)
2834     return -1;
2835   else
2836     {
2837       r = get_parameter (para, pKEYUSAGE);
2838       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2839         {
2840           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2841                      fname, r->lnr, algo);
2842           return -1;
2843         }
2844     }
2845
2846   is_default = 0;
2847   r = get_parameter( para, pSUBKEYTYPE );
2848   if(r)
2849     {
2850       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
2851       if (openpgp_pk_test_algo (algo))
2852         {
2853           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2854           return -1;
2855         }
2856
2857       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2858       if (!err)
2859         {
2860           /* Default to algo capabilities if subkey-usage is not
2861              provided */
2862           r = xmalloc_clear (sizeof(*r));
2863           r->key = pSUBKEYUSAGE;
2864           r->u.usage = (is_default
2865                         ? PUBKEY_USAGE_ENC
2866                         : openpgp_pk_algo_usage (algo));
2867           append_to_parameter (para, r);
2868         }
2869       else if (err == -1)
2870         return -1;
2871       else
2872         {
2873           r = get_parameter (para, pSUBKEYUSAGE);
2874           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2875             {
2876               log_error ("%s:%d: specified Subkey-Usage not allowed"
2877                          " for algo %d\n", fname, r->lnr, algo);
2878               return -1;
2879             }
2880         }
2881     }
2882
2883
2884   if( get_parameter_value( para, pUSERID ) )
2885     have_user_id=1;
2886   else
2887     {
2888       /* create the formatted user ID */
2889       s1 = get_parameter_value( para, pNAMEREAL );
2890       s2 = get_parameter_value( para, pNAMECOMMENT );
2891       s3 = get_parameter_value( para, pNAMEEMAIL );
2892       if( s1 || s2 || s3 )
2893         {
2894           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2895           r = xmalloc_clear( sizeof *r + n + 20 );
2896           r->key = pUSERID;
2897           p = r->u.value;
2898           if( s1 )
2899             p = stpcpy(p, s1 );
2900           if( s2 )
2901             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2902           if( s3 )
2903             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2904           append_to_parameter (para, r);
2905           have_user_id=1;
2906         }
2907     }
2908
2909   if(!have_user_id)
2910     {
2911       log_error("%s: no User-ID specified\n",fname);
2912       return -1;
2913     }
2914
2915   /* Set preferences, if any. */
2916   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2917
2918   /* Set keyserver, if any. */
2919   s1=get_parameter_value( para, pKEYSERVER );
2920   if(s1)
2921     {
2922       struct keyserver_spec *spec;
2923
2924       spec=parse_keyserver_uri(s1,1,NULL,0);
2925       if(spec)
2926         {
2927           free_keyserver_spec(spec);
2928           opt.def_keyserver_url=s1;
2929         }
2930       else
2931         {
2932           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2933           return -1;
2934         }
2935     }
2936
2937   /* Set revoker, if any. */
2938   if (parse_revocation_key (fname, para, pREVOKER))
2939     return -1;
2940
2941   /* Make DEK and S2K from the Passphrase. */
2942   if (outctrl->ask_passphrase)
2943     {
2944       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
2945          feature is required so that GUIs are able to do a key
2946          creation but have gpg-agent ask for the passphrase.  */
2947       int canceled = 0;
2948       STRING2KEY *s2k;
2949       DEK *dek;
2950
2951       dek = do_ask_passphrase (&s2k, 0, &canceled);
2952       if (dek)
2953         {
2954           r = xmalloc_clear( sizeof *r );
2955           r->key = pPASSPHRASE_DEK;
2956           r->u.dek = dek;
2957           append_to_parameter (para, r);
2958           r = xmalloc_clear( sizeof *r );
2959           r->key = pPASSPHRASE_S2K;
2960           r->u.s2k = s2k;
2961           append_to_parameter (para, r);
2962         }
2963
2964       if (canceled)
2965         {
2966           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
2967           return -1;
2968         }
2969     }
2970   else
2971     {
2972       r = get_parameter( para, pPASSPHRASE );
2973       if ( r && *r->u.value )
2974         {
2975           /* We have a plain text passphrase - create a DEK from it.
2976            * It is a little bit ridiculous to keep it in secure memory
2977            * but because we do this always, why not here.  */
2978           STRING2KEY *s2k;
2979           DEK *dek;
2980           static int count;
2981
2982           s2k = xmalloc ( sizeof *s2k );
2983           s2k->mode = opt.s2k_mode;
2984           s2k->hash_algo = S2K_DIGEST_ALGO;
2985           set_next_passphrase ( r->u.value );
2986           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2987                                    NULL, NULL);
2988           if (!dek)
2989             {
2990               log_error ("%s:%d: error post processing the passphrase\n",
2991                          fname, r->lnr );
2992               xfree (s2k);
2993               return -1;
2994             }
2995           set_next_passphrase (NULL);
2996           memset (r->u.value, 0, strlen(r->u.value));
2997
2998           r = xmalloc_clear (sizeof *r);
2999           r->key = pPASSPHRASE_S2K;
3000           r->u.s2k = s2k;
3001           append_to_parameter (para, r);
3002           r = xmalloc_clear (sizeof *r);
3003           r->key = pPASSPHRASE_DEK;
3004           r->u.dek = dek;
3005           append_to_parameter (para, r);
3006         }
3007     }
3008
3009   /* Make KEYCREATIONDATE from Creation-Date.  */
3010   r = get_parameter (para, pCREATIONDATE);
3011   if (r && *r->u.value)
3012     {
3013       u32 seconds;
3014
3015       seconds = parse_creation_string (r->u.value);
3016       if (!seconds)
3017         {
3018           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
3019           return -1;
3020         }
3021       r->u.creation = seconds;
3022       r->key = pKEYCREATIONDATE;  /* Change that entry. */
3023     }
3024
3025   /* Make KEYEXPIRE from Expire-Date.  */
3026   r = get_parameter( para, pEXPIREDATE );
3027   if( r && *r->u.value )
3028     {
3029       u32 seconds;
3030
3031       seconds = parse_expire_string( r->u.value );
3032       if( seconds == (u32)-1 )
3033         {
3034           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
3035           return -1;
3036         }
3037       r->u.expire = seconds;
3038       r->key = pKEYEXPIRE;  /* change hat entry */
3039       /* also set it for the subkey */
3040       r = xmalloc_clear( sizeof *r + 20 );
3041       r->key = pSUBKEYEXPIRE;
3042       r->u.expire = seconds;
3043       append_to_parameter (para, r);
3044     }
3045
3046   do_generate_keypair( para, outctrl, card );
3047   return 0;
3048 }
3049
3050
3051 /****************
3052  * Kludge to allow non interactive key generation controlled
3053  * by a parameter file.
3054  * Note, that string parameters are expected to be in UTF-8
3055  */
3056 static void
3057 read_parameter_file( const char *fname )
3058 {
3059     static struct { const char *name;
3060                     enum para_name key;
3061     } keywords[] = {
3062         { "Key-Type",       pKEYTYPE},
3063         { "Key-Length",     pKEYLENGTH },
3064         { "Key-Usage",      pKEYUSAGE },
3065         { "Subkey-Type",    pSUBKEYTYPE },
3066         { "Subkey-Length",  pSUBKEYLENGTH },
3067         { "Subkey-Usage",   pSUBKEYUSAGE },
3068         { "Name-Real",      pNAMEREAL },
3069         { "Name-Email",     pNAMEEMAIL },
3070         { "Name-Comment",   pNAMECOMMENT },
3071         { "Expire-Date",    pEXPIREDATE },
3072         { "Creation-Date",  pCREATIONDATE },
3073         { "Passphrase",     pPASSPHRASE },
3074         { "Preferences",    pPREFERENCES },
3075         { "Revoker",        pREVOKER },
3076         { "Handle",         pHANDLE },
3077         { "Keyserver",      pKEYSERVER },
3078         { NULL, 0 }
3079     };
3080     IOBUF fp;
3081     byte *line;
3082     unsigned int maxlen, nline;
3083     char *p;
3084     int lnr;
3085     const char *err = NULL;
3086     struct para_data_s *para, *r;
3087     int i;
3088     struct output_control_s outctrl;
3089
3090     memset( &outctrl, 0, sizeof( outctrl ) );
3091     outctrl.pub.afx = new_armor_context ();
3092
3093     if( !fname || !*fname)
3094       fname = "-";
3095
3096     fp = iobuf_open (fname);
3097     if (fp && is_secured_file (iobuf_get_fd (fp)))
3098       {
3099         iobuf_close (fp);
3100         fp = NULL;
3101         gpg_err_set_errno (EPERM);
3102       }
3103     if (!fp) {
3104       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
3105       return;
3106     }
3107     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
3108
3109     lnr = 0;
3110     err = NULL;
3111     para = NULL;
3112     maxlen = 1024;
3113     line = NULL;
3114     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
3115         char *keyword, *value;
3116
3117         lnr++;
3118         if( !maxlen ) {
3119             err = "line too long";
3120             break;
3121         }
3122         for( p = line; isspace(*(byte*)p); p++ )
3123             ;
3124         if( !*p || *p == '#' )
3125             continue;
3126         keyword = p;
3127         if( *keyword == '%' ) {
3128             for( ; !isspace(*(byte*)p); p++ )
3129                 ;
3130             if( *p )
3131                 *p++ = 0;
3132             for( ; isspace(*(byte*)p); p++ )
3133                 ;
3134             value = p;
3135             trim_trailing_ws( value, strlen(value) );
3136             if( !ascii_strcasecmp( keyword, "%echo" ) )
3137                 log_info("%s\n", value );
3138             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
3139                 outctrl.dryrun = 1;
3140             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
3141                 outctrl.ask_passphrase = 1;
3142             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
3143                 outctrl.ask_passphrase = 0;
3144             else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
3145                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
3146             else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
3147                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
3148             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
3149                 outctrl.lnr = lnr;
3150                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
3151                   print_status_key_not_created
3152                     (get_parameter_value (para, pHANDLE));
3153                 release_parameter_list( para );
3154                 para = NULL;
3155             }
3156             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
3157                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
3158                     ; /* still the same file - ignore it */
3159                 else {
3160                     xfree( outctrl.pub.newfname );
3161                     outctrl.pub.newfname = xstrdup( value );
3162                     outctrl.use_files = 1;
3163                 }
3164             }
3165             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
3166               /* Ignore this command.  */
3167             }
3168             else
3169                 log_info("skipping control '%s' (%s)\n", keyword, value );
3170
3171
3172             continue;
3173         }
3174
3175
3176         if( !(p = strchr( p, ':' )) || p == keyword ) {
3177             err = "missing colon";
3178             break;
3179         }
3180         if( *p )
3181             *p++ = 0;
3182         for( ; isspace(*(byte*)p); p++ )
3183             ;
3184         if( !*p ) {
3185             err = "missing argument";
3186             break;
3187         }
3188         value = p;
3189         trim_trailing_ws( value, strlen(value) );
3190
3191         for(i=0; keywords[i].name; i++ ) {
3192             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
3193                 break;
3194         }
3195         if( !keywords[i].name ) {
3196             err = "unknown keyword";
3197             break;
3198         }
3199         if( keywords[i].key != pKEYTYPE && !para ) {
3200             err = "parameter block does not start with \"Key-Type\"";
3201             break;
3202         }
3203
3204         if( keywords[i].key == pKEYTYPE && para ) {
3205             outctrl.lnr = lnr;
3206             if (proc_parameter_file( para, fname, &outctrl, 0 ))
3207               print_status_key_not_created
3208                 (get_parameter_value (para, pHANDLE));
3209             release_parameter_list( para );
3210             para = NULL;
3211         }
3212         else {
3213             for( r = para; r; r = r->next ) {
3214                 if( r->key == keywords[i].key )
3215                     break;
3216             }
3217             if( r ) {
3218                 err = "duplicate keyword";
3219                 break;
3220             }
3221         }
3222         r = xmalloc_clear( sizeof *r + strlen( value ) );
3223         r->lnr = lnr;
3224         r->key = keywords[i].key;
3225         strcpy( r->u.value, value );
3226         r->next = para;
3227         para = r;
3228     }
3229     if( err )
3230         log_error("%s:%d: %s\n", fname, lnr, err );
3231     else if( iobuf_error (fp) ) {
3232         log_error("%s:%d: read error\n", fname, lnr);
3233     }
3234     else if( para ) {
3235         outctrl.lnr = lnr;
3236         if (proc_parameter_file( para, fname, &outctrl, 0 ))
3237           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3238     }
3239
3240     if( outctrl.use_files ) { /* close open streams */
3241         iobuf_close( outctrl.pub.stream );
3242
3243         /* Must invalidate that ugly cache to actually close it.  */
3244         if (outctrl.pub.fname)
3245           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3246                        0, (char*)outctrl.pub.fname);
3247
3248         xfree( outctrl.pub.fname );
3249         xfree( outctrl.pub.newfname );
3250     }
3251
3252     release_parameter_list( para );
3253     iobuf_close (fp);
3254     release_armor_context (outctrl.pub.afx);
3255 }
3256
3257
3258 /*
3259  * Generate a keypair (fname is only used in batch mode) If
3260  * CARD_SERIALNO is not NULL the function will create the keys on an
3261  * OpenPGP Card.  If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
3262  * NOT NULL, the encryption key for the card is generated on the host,
3263  * imported to the card and a backup file created by gpg-agent.
3264  */
3265 void
3266 generate_keypair (ctrl_t ctrl, const char *fname, const char *card_serialno,
3267                   int card_backup_key)
3268 {
3269   unsigned int nbits;
3270   char *uid = NULL;
3271   int algo;
3272   unsigned int use;
3273   int both = 0;
3274   u32 expire;
3275   struct para_data_s *para = NULL;
3276   struct para_data_s *r;
3277   struct output_control_s outctrl;
3278
3279   memset( &outctrl, 0, sizeof( outctrl ) );
3280
3281   if (opt.batch && card_serialno)
3282     {
3283       /* We don't yet support unattended key generation. */
3284       log_error (_("can't do this in batch mode\n"));
3285       return;
3286     }
3287
3288   if (opt.batch)
3289     {
3290       read_parameter_file( fname );
3291       return;
3292     }
3293
3294   if (card_serialno)
3295     {
3296 #ifdef ENABLE_CARD_SUPPORT
3297       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3298       r->key = pSERIALNO;
3299       strcpy( r->u.value, card_serialno);
3300       r->next = para;
3301       para = r;
3302
3303       algo = PUBKEY_ALGO_RSA;
3304
3305       r = xcalloc (1, sizeof *r + 20 );
3306       r->key = pKEYTYPE;
3307       sprintf( r->u.value, "%d", algo );
3308       r->next = para;
3309       para = r;
3310       r = xcalloc (1, sizeof *r + 20 );
3311       r->key = pKEYUSAGE;
3312       strcpy (r->u.value, "sign");
3313       r->next = para;
3314       para = r;
3315
3316       r = xcalloc (1, sizeof *r + 20 );
3317       r->key = pSUBKEYTYPE;
3318       sprintf( r->u.value, "%d", algo );
3319       r->next = para;
3320       para = r;
3321       r = xcalloc (1, sizeof *r + 20 );
3322       r->key = pSUBKEYUSAGE;
3323       strcpy (r->u.value, "encrypt");
3324       r->next = para;
3325       para = r;
3326
3327       r = xcalloc (1, sizeof *r + 20 );
3328       r->key = pAUTHKEYTYPE;
3329       sprintf( r->u.value, "%d", algo );
3330       r->next = para;
3331       para = r;
3332
3333       if (card_backup_key)
3334         {
3335           r = xcalloc (1, sizeof *r + 1);
3336           r->key = pCARDBACKUPKEY;
3337           strcpy (r->u.value, "1");
3338           r->next = para;
3339           para = r;
3340         }
3341 #endif /*ENABLE_CARD_SUPPORT*/
3342     }
3343   else
3344     {
3345       int subkey_algo;
3346
3347       /* Fixme: To support creating a primary key by keygrip we better
3348          also define the keyword for the parameter file.  Note that
3349          the subkey case will never be asserted if a keygrip has been
3350          given.  */
3351       algo = ask_algo (ctrl, 0, &subkey_algo, &use, NULL);
3352       if (subkey_algo)
3353         {
3354           /* Create primary and subkey at once.  */
3355           both = 1;
3356           r = xmalloc_clear( sizeof *r + 20 );
3357           r->key = pKEYTYPE;
3358           sprintf( r->u.value, "%d", algo );
3359           r->next = para;
3360           para = r;
3361           nbits = ask_keysize (algo, 0);
3362           r = xmalloc_clear( sizeof *r + 20 );
3363           r->key = pKEYLENGTH;
3364           sprintf( r->u.value, "%u", nbits);
3365           r->next = para;
3366           para = r;
3367           r = xmalloc_clear( sizeof *r + 20 );
3368           r->key = pKEYUSAGE;
3369           strcpy( r->u.value, "sign" );
3370           r->next = para;
3371           para = r;
3372
3373           r = xmalloc_clear( sizeof *r + 20 );
3374           r->key = pSUBKEYTYPE;
3375           sprintf( r->u.value, "%d", subkey_algo);
3376           r->next = para;
3377           para = r;
3378           r = xmalloc_clear( sizeof *r + 20 );
3379           r->key = pSUBKEYUSAGE;
3380           strcpy( r->u.value, "encrypt" );
3381           r->next = para;
3382           para = r;
3383         }
3384       else
3385         {
3386           r = xmalloc_clear( sizeof *r + 20 );
3387           r->key = pKEYTYPE;
3388           sprintf( r->u.value, "%d", algo );
3389           r->next = para;
3390           para = r;
3391
3392           if (use)
3393             {
3394               r = xmalloc_clear( sizeof *r + 25 );
3395               r->key = pKEYUSAGE;
3396               sprintf( r->u.value, "%s%s%s",
3397                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3398                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3399                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3400               r->next = para;
3401               para = r;
3402             }
3403           nbits = 0;
3404         }
3405
3406       nbits = ask_keysize (both? subkey_algo : algo, nbits);
3407       r = xmalloc_clear( sizeof *r + 20 );
3408       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3409       sprintf( r->u.value, "%u", nbits);
3410       r->next = para;
3411       para = r;
3412     }
3413
3414   expire = ask_expire_interval(0,NULL);
3415   r = xmalloc_clear( sizeof *r + 20 );
3416   r->key = pKEYEXPIRE;
3417   r->u.expire = expire;
3418   r->next = para;
3419   para = r;
3420   r = xmalloc_clear( sizeof *r + 20 );
3421   r->key = pSUBKEYEXPIRE;
3422   r->u.expire = expire;
3423   r->next = para;
3424   para = r;
3425
3426   uid = ask_user_id (0, NULL);
3427   if( !uid )
3428     {
3429       log_error(_("Key generation canceled.\n"));
3430       release_parameter_list( para );
3431       return;
3432     }
3433   r = xmalloc_clear( sizeof *r + strlen(uid) );
3434   r->key = pUSERID;
3435   strcpy( r->u.value, uid );
3436   r->next = para;
3437   para = r;
3438
3439   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3440   release_parameter_list( para );
3441 }
3442
3443
3444 #if 0 /* not required */
3445 /* Generate a raw key and return it as a secret key packet.  The
3446    function will ask for the passphrase and return a protected as well
3447    as an unprotected copy of a new secret key packet.  0 is returned
3448    on success and the caller must then free the returned values.  */
3449 static int
3450 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3451                   PKT_secret_key **r_sk_unprotected,
3452                   PKT_secret_key **r_sk_protected)
3453 {
3454   int rc;
3455   DEK *dek = NULL;
3456   STRING2KEY *s2k = NULL;
3457   PKT_secret_key *sk = NULL;
3458   int i;
3459   size_t nskey, npkey;
3460   gcry_sexp_t s_parms, s_key;
3461   int canceled;
3462
3463   npkey = pubkey_get_npkey (algo);
3464   nskey = pubkey_get_nskey (algo);
3465   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3466
3467   if (nbits < 512)
3468     {
3469       nbits = 512;
3470       log_info (_("keysize invalid; using %u bits\n"), nbits );
3471     }
3472
3473   if ((nbits % 32))
3474     {
3475       nbits = ((nbits + 31) / 32) * 32;
3476       log_info(_("keysize rounded up to %u bits\n"), nbits );
3477     }
3478
3479   dek = do_ask_passphrase (&s2k, 1, &canceled);
3480   if (canceled)
3481     {
3482       rc = gpg_error (GPG_ERR_CANCELED);
3483       goto leave;
3484     }
3485
3486   sk = xmalloc_clear (sizeof *sk);
3487   sk->timestamp = created_at;
3488   sk->version = 4;
3489   sk->pubkey_algo = algo;
3490
3491   if ( !is_RSA (algo) )
3492     {
3493       log_error ("only RSA is supported for offline generated keys\n");
3494       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3495       goto leave;
3496     }
3497   rc = gcry_sexp_build (&s_parms, NULL,
3498                         "(genkey(rsa(nbits %d)))",
3499                         (int)nbits);
3500   if (rc)
3501     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3502   rc = gcry_pk_genkey (&s_key, s_parms);
3503   gcry_sexp_release (s_parms);
3504   if (rc)
3505     {
3506       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3507       goto leave;
3508     }
3509   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3510   gcry_sexp_release (s_key);
3511   if (rc)
3512     {
3513       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3514       goto leave;
3515     }
3516
3517   for (i=npkey; i < nskey; i++)
3518     sk->csum += checksum_mpi (sk->skey[i]);
3519
3520   if (r_sk_unprotected)
3521     *r_sk_unprotected = copy_secret_key (NULL, sk);
3522
3523   rc = genhelp_protect (dek, s2k, sk);
3524   if (rc)
3525     goto leave;
3526
3527   if (r_sk_protected)
3528     {
3529       *r_sk_protected = sk;
3530       sk = NULL;
3531     }
3532
3533  leave:
3534   if (sk)
3535     free_secret_key (sk);
3536   xfree (dek);
3537   xfree (s2k);
3538   return rc;
3539 }
3540 #endif /* ENABLE_CARD_SUPPORT */
3541
3542 /* Create and delete a dummy packet to start off a list of kbnodes. */
3543 static void
3544 start_tree(KBNODE *tree)
3545 {
3546   PACKET *pkt;
3547
3548   pkt=xmalloc_clear(sizeof(*pkt));
3549   pkt->pkttype=PKT_NONE;
3550   *tree=new_kbnode(pkt);
3551   delete_kbnode(*tree);
3552 }
3553
3554
3555 static void
3556 do_generate_keypair (struct para_data_s *para,
3557                      struct output_control_s *outctrl, int card)
3558 {
3559   gpg_error_t err;
3560   KBNODE pub_root = NULL;
3561   const char *s;
3562   PKT_public_key *pri_psk = NULL;
3563   PKT_public_key *sub_psk = NULL;
3564   struct revocation_key *revkey;
3565   int did_sub = 0;
3566   u32 timestamp;
3567   char *cache_nonce = NULL;
3568
3569   if (outctrl->dryrun)
3570     {
3571       log_info("dry-run mode - key generation skipped\n");
3572       return;
3573     }
3574
3575   if ( outctrl->use_files )
3576     {
3577       if ( outctrl->pub.newfname )
3578         {
3579           iobuf_close(outctrl->pub.stream);
3580           outctrl->pub.stream = NULL;
3581           if (outctrl->pub.fname)
3582             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3583                          0, (char*)outctrl->pub.fname);
3584           xfree( outctrl->pub.fname );
3585           outctrl->pub.fname =  outctrl->pub.newfname;
3586           outctrl->pub.newfname = NULL;
3587
3588           if (is_secured_filename (outctrl->pub.fname) )
3589             {
3590               outctrl->pub.stream = NULL;
3591               gpg_err_set_errno (EPERM);
3592             }
3593           else
3594             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3595           if (!outctrl->pub.stream)
3596             {
3597               log_error(_("can't create '%s': %s\n"), outctrl->pub.newfname,
3598                         strerror(errno) );
3599               return;
3600             }
3601           if (opt.armor)
3602             {
3603               outctrl->pub.afx->what = 1;
3604               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3605             }
3606         }
3607       assert( outctrl->pub.stream );
3608       if (opt.verbose)
3609         log_info (_("writing public key to '%s'\n"), outctrl->pub.fname );
3610     }
3611
3612
3613   /* We create the packets as a tree of kbnodes.  Because the
3614      structure we create is known in advance we simply generate a
3615      linked list.  The first packet is a dummy packet which we flag as
3616      deleted.  The very first packet must always be a KEY packet.  */
3617
3618   start_tree (&pub_root);
3619
3620   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3621   if (!timestamp)
3622     timestamp = make_timestamp ();
3623
3624   /* Note that, depending on the backend (i.e. the used scdaemon
3625      version), the card key generation may update TIMESTAMP for each
3626      key.  Thus we need to pass TIMESTAMP to all signing function to
3627      make sure that the binding signature is done using the timestamp
3628      of the corresponding (sub)key and not that of the primary key.
3629      An alternative implementation could tell the signing function the
3630      node of the subkey but that is more work than just to pass the
3631      current timestamp.  */
3632
3633   if (!card)
3634     err = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
3635                      get_parameter_uint( para, pKEYLENGTH ),
3636                      pub_root,
3637                      timestamp,
3638                      get_parameter_u32( para, pKEYEXPIRE ), 0,
3639                      outctrl->keygen_flags, &cache_nonce);
3640   else
3641     err = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root,
3642                         &timestamp,
3643                         get_parameter_u32 (para, pKEYEXPIRE));
3644
3645   /* Get the pointer to the generated public key packet.  */
3646   if (!err)
3647     {
3648       pri_psk = pub_root->next->pkt->pkt.public_key;
3649       assert (pri_psk);
3650     }
3651
3652   if (!err && (revkey = get_parameter_revkey (para, pREVOKER)))
3653     err = write_direct_sig (pub_root, pri_psk, revkey, timestamp, cache_nonce);
3654
3655   if (!err && (s = get_parameter_value (para, pUSERID)))
3656     {
3657       write_uid (pub_root, s );
3658       err = write_selfsigs (pub_root, pri_psk,
3659                             get_parameter_uint (para, pKEYUSAGE), timestamp,
3660                             cache_nonce);
3661     }
3662
3663   /* Write the auth key to the card before the encryption key.  This
3664      is a partial workaround for a PGP bug (as of this writing, all
3665      versions including 8.1), that causes it to try and encrypt to
3666      the most recent subkey regardless of whether that subkey is