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