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