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