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