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