4ff68941ead070369f5c404fc73f767e9c4301ae
[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( has_invalid_email_chars(amail)
1659                          || string_count_chr(amail,'@') != 1
1660                          || *amail == '@'
1661                          || amail[strlen(amail)-1] == '@'
1662                          || amail[strlen(amail)-1] == '.'
1663                          || strstr(amail, "..") )
1664                     tty_printf(_("Not a valid email address\n"));
1665                 else
1666                     break;
1667             }
1668         }
1669         if( !acomment ) {
1670             for(;;) {
1671                 xfree(acomment);
1672                 acomment = cpr_get("keygen.comment",_("Comment: "));
1673                 trim_spaces(acomment);
1674                 cpr_kill_prompt();
1675                 if( !*acomment )
1676                     break;   /* no comment is okay */
1677                 else if( strpbrk( acomment, "()" ) )
1678                     tty_printf(_("Invalid character in comment\n"));
1679                 else
1680                     break;
1681             }
1682         }
1683
1684
1685         xfree(uid);
1686         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1687         p = stpcpy(p, aname );
1688         if( *acomment )
1689             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1690         if( *amail )
1691             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1692
1693         /* append a warning if we do not have dev/random
1694          * or it is switched into  quick testmode */
1695         if( quick_random_gen(-1) )
1696             strcpy(p, " (INSECURE!)" );
1697
1698         /* print a note in case that UTF8 mapping has to be done */
1699         for(p=uid; *p; p++ ) {
1700             if( *p & 0x80 ) {
1701                 tty_printf(_("You are using the `%s' character set.\n"),
1702                            get_native_charset() );
1703                 break;
1704             }
1705         }
1706
1707         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1708         /* fixme: add a warning if this user-id already exists */
1709         if( !*amail && !opt.allow_freeform_uid
1710             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1711             fail = 1;
1712             tty_printf(_("Please don't put the email address "
1713                           "into the real name or the comment\n") );
1714         }
1715
1716         for(;;) {
1717             /* TRANSLATORS: These are the allowed answers in
1718                lower and uppercase.  Below you will find the matching
1719                string which should be translated accordingly and the
1720                letter changed to match the one in the answer string.
1721                
1722                  n = Change name
1723                  c = Change comment
1724                  e = Change email
1725                  o = Okay (ready, continue)
1726                  q = Quit
1727              */
1728             const char *ansstr = _("NnCcEeOoQq");
1729
1730             if( strlen(ansstr) != 10 )
1731                 BUG();
1732             if( cpr_enabled() ) {
1733                 answer = xstrdup(ansstr+6);
1734                 answer[1] = 0;
1735             }
1736             else {
1737                 answer = cpr_get("keygen.userid.cmd", fail?
1738                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1739                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1740                 cpr_kill_prompt();
1741             }
1742             if( strlen(answer) > 1 )
1743                 ;
1744             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1745                 xfree(aname); aname = NULL;
1746                 break;
1747             }
1748             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1749                 xfree(acomment); acomment = NULL;
1750                 break;
1751             }
1752             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1753                 xfree(amail); amail = NULL;
1754                 break;
1755             }
1756             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1757                 if( fail ) {
1758                     tty_printf(_("Please correct the error first\n"));
1759                 }
1760                 else {
1761                     xfree(aname); aname = NULL;
1762                     xfree(acomment); acomment = NULL;
1763                     xfree(amail); amail = NULL;
1764                     break;
1765                 }
1766             }
1767             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1768                 xfree(aname); aname = NULL;
1769                 xfree(acomment); acomment = NULL;
1770                 xfree(amail); amail = NULL;
1771                 xfree(uid); uid = NULL;
1772                 break;
1773             }
1774             xfree(answer);
1775         }
1776         xfree(answer);
1777         if( !amail && !acomment && !amail )
1778             break;
1779         xfree(uid); uid = NULL;
1780     }
1781     if( uid ) {
1782         char *p = native_to_utf8( uid );
1783         xfree( uid );
1784         uid = p;
1785     }
1786     return uid;
1787 }
1788
1789
1790 /* FIXME: We need a way to cancel this prompt. */
1791 static DEK *
1792 do_ask_passphrase( STRING2KEY **ret_s2k )
1793 {
1794     DEK *dek = NULL;
1795     STRING2KEY *s2k;
1796     const char *errtext = NULL;
1797
1798     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1799
1800     s2k = xmalloc_secure( sizeof *s2k );
1801     for(;;) {
1802         s2k->mode = opt.s2k_mode;
1803         s2k->hash_algo = S2K_DIGEST_ALGO;
1804         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1805                                  errtext, NULL);
1806         if( !dek ) {
1807             errtext = N_("passphrase not correctly repeated; try again");
1808             tty_printf(_("%s.\n"), _(errtext));
1809         }
1810         else if( !dek->keylen ) {
1811             xfree(dek); dek = NULL;
1812             xfree(s2k); s2k = NULL;
1813             tty_printf(_(
1814             "You don't want a passphrase - this is probably a *bad* idea!\n"
1815             "I will do it anyway.  You can change your passphrase at any time,\n"
1816             "using this program with the option \"--edit-key\".\n\n"));
1817             break;
1818         }
1819         else
1820             break; /* okay */
1821     }
1822     *ret_s2k = s2k;
1823     return dek;
1824 }
1825
1826
1827 static int
1828 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1829            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
1830            int is_subkey )
1831 {
1832   int rc=0;
1833
1834   if( !opt.batch )
1835     tty_printf(_(
1836 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1837 "some other action (type on the keyboard, move the mouse, utilize the\n"
1838 "disks) during the prime generation; this gives the random number\n"
1839 "generator a better chance to gain enough entropy.\n") );
1840
1841   if( algo == PUBKEY_ALGO_ELGAMAL_E )
1842     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1843                  is_subkey);
1844   else if( algo == PUBKEY_ALGO_DSA )
1845     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1846                  is_subkey);
1847   else if( algo == PUBKEY_ALGO_RSA )
1848     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1849                  is_subkey);
1850   else
1851     BUG();
1852
1853   return rc;
1854 }
1855
1856
1857 /****************
1858  * Generate a new user id packet, or return NULL if canceled
1859  */
1860 PKT_user_id *
1861 generate_user_id()
1862 {
1863     PKT_user_id *uid;
1864     char *p;
1865     size_t n;
1866
1867     p = ask_user_id( 1 );
1868     if( !p )
1869         return NULL;
1870     n = strlen(p);
1871     uid = xmalloc_clear( sizeof *uid + n - 1 );
1872     uid->len = n;
1873     strcpy(uid->name, p);
1874     uid->ref = 1;
1875     return uid;
1876 }
1877
1878
1879 static void
1880 release_parameter_list( struct para_data_s *r )
1881 {
1882     struct para_data_s *r2;
1883
1884     for( ; r ; r = r2 ) {
1885         r2 = r->next;
1886         if( r->key == pPASSPHRASE_DEK )
1887             xfree( r->u.dek );
1888         else if( r->key == pPASSPHRASE_S2K )
1889             xfree( r->u.s2k );
1890
1891         xfree(r);
1892     }
1893 }
1894
1895 static struct para_data_s *
1896 get_parameter( struct para_data_s *para, enum para_name key )
1897 {
1898     struct para_data_s *r;
1899
1900     for( r = para; r && r->key != key; r = r->next )
1901         ;
1902     return r;
1903 }
1904
1905 static const char *
1906 get_parameter_value( struct para_data_s *para, enum para_name key )
1907 {
1908     struct para_data_s *r = get_parameter( para, key );
1909     return (r && *r->u.value)? r->u.value : NULL;
1910 }
1911
1912 static int
1913 get_parameter_algo( struct para_data_s *para, enum para_name key )
1914 {
1915     int i;
1916     struct para_data_s *r = get_parameter( para, key );
1917     if( !r )
1918         return -1;
1919     if( digitp( r->u.value ) )
1920         i = atoi( r->u.value );
1921     else
1922         i = string_to_pubkey_algo( r->u.value );
1923     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1924       i = 0; /* we don't want to allow generation of these algorithms */
1925     return i;
1926 }
1927
1928 /* 
1929  * parse the usage parameter and set the keyflags.  Return true on error.
1930  */
1931 static int
1932 parse_parameter_usage (const char *fname,
1933                        struct para_data_s *para, enum para_name key)
1934 {
1935     struct para_data_s *r = get_parameter( para, key );
1936     char *p, *pn;
1937     unsigned int use;
1938
1939     if( !r )
1940         return 0; /* none (this is an optional parameter)*/
1941     
1942     use = 0;
1943     pn = r->u.value;
1944     while ( (p = strsep (&pn, " \t,")) ) {
1945         if ( !*p)
1946             ;
1947         else if ( !ascii_strcasecmp (p, "sign") )
1948             use |= PUBKEY_USAGE_SIG;
1949         else if ( !ascii_strcasecmp (p, "encrypt") )
1950             use |= PUBKEY_USAGE_ENC;
1951         else if ( !ascii_strcasecmp (p, "auth") )
1952             use |= PUBKEY_USAGE_AUTH;
1953         else {
1954             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1955             return -1; /* error */
1956         }
1957     }
1958     r->u.usage = use;
1959     return 0;
1960 }
1961
1962 static int
1963 parse_revocation_key (const char *fname,
1964                       struct para_data_s *para, enum para_name key)
1965 {
1966   struct para_data_s *r = get_parameter( para, key );
1967   struct revocation_key revkey;
1968   char *pn;
1969   int i;
1970
1971   if( !r )
1972     return 0; /* none (this is an optional parameter) */
1973
1974   pn = r->u.value;
1975
1976   revkey.class=0x80;
1977   revkey.algid=atoi(pn);
1978   if(!revkey.algid)
1979     goto fail;
1980
1981   /* Skip to the fpr */
1982   while(*pn && *pn!=':')
1983     pn++;
1984
1985   if(*pn!=':')
1986     goto fail;
1987
1988   pn++;
1989
1990   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1991     {
1992       int c=hextobyte(pn);
1993       if(c==-1)
1994         goto fail;
1995
1996       revkey.fpr[i]=c;
1997     }
1998
1999   /* skip to the tag */
2000   while(*pn && *pn!='s' && *pn!='S')
2001     pn++;
2002
2003   if(ascii_strcasecmp(pn,"sensitive")==0)
2004     revkey.class|=0x40;
2005
2006   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2007
2008   return 0;
2009
2010   fail:
2011   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2012   return -1; /* error */
2013 }
2014
2015
2016 static u32
2017 get_parameter_u32( struct para_data_s *para, enum para_name key )
2018 {
2019     struct para_data_s *r = get_parameter( para, key );
2020
2021     if( !r )
2022         return 0;
2023     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2024         return r->u.expire;
2025     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2026         return r->u.usage;
2027
2028     return (unsigned int)strtoul( r->u.value, NULL, 10 );
2029 }
2030
2031 static unsigned int
2032 get_parameter_uint( struct para_data_s *para, enum para_name key )
2033 {
2034     return get_parameter_u32( para, key );
2035 }
2036
2037 static DEK *
2038 get_parameter_dek( struct para_data_s *para, enum para_name key )
2039 {
2040     struct para_data_s *r = get_parameter( para, key );
2041     return r? r->u.dek : NULL;
2042 }
2043
2044 static STRING2KEY *
2045 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2046 {
2047     struct para_data_s *r = get_parameter( para, key );
2048     return r? r->u.s2k : NULL;
2049 }
2050
2051 static struct revocation_key *
2052 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2053 {
2054     struct para_data_s *r = get_parameter( para, key );
2055     return r? &r->u.revkey : NULL;
2056 }
2057
2058 static int
2059 proc_parameter_file( struct para_data_s *para, const char *fname,
2060                      struct output_control_s *outctrl, int card )
2061 {
2062     struct para_data_s *r;
2063     const char *s1, *s2, *s3;
2064     size_t n;
2065     char *p;
2066     int i;
2067
2068     /* Check that we have all required parameters. */
2069     assert( get_parameter( para, pKEYTYPE ) );
2070     i = get_parameter_algo( para, pKEYTYPE );
2071     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
2072         r = get_parameter( para, pKEYTYPE );
2073         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2074         return -1;
2075     }
2076
2077     if (parse_parameter_usage (fname, para, pKEYUSAGE))
2078         return -1;
2079
2080     i = get_parameter_algo( para, pSUBKEYTYPE );
2081     if( i > 0 && check_pubkey_algo( i ) ) {
2082         r = get_parameter( para, pSUBKEYTYPE );
2083         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2084         return -1;
2085     }
2086     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
2087         return -1;
2088
2089
2090     if( !get_parameter_value( para, pUSERID ) ) {
2091         /* create the formatted user ID */
2092         s1 = get_parameter_value( para, pNAMEREAL );
2093         s2 = get_parameter_value( para, pNAMECOMMENT );
2094         s3 = get_parameter_value( para, pNAMEEMAIL );
2095         if( s1 || s2 || s3 ) {
2096             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2097             r = xmalloc_clear( sizeof *r + n + 20 );
2098             r->key = pUSERID;
2099             p = r->u.value;
2100             if( s1 )
2101                 p = stpcpy(p, s1 );
2102             if( s2 )
2103                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2104             if( s3 )
2105                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2106             r->next = para;
2107             para = r;
2108         }
2109     }
2110
2111     /* Set preferences, if any. */
2112     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2113
2114     /* Set revoker, if any. */
2115     if (parse_revocation_key (fname, para, pREVOKER))
2116       return -1;
2117
2118     /* make DEK and S2K from the Passphrase */
2119     r = get_parameter( para, pPASSPHRASE );
2120     if( r && *r->u.value ) {
2121         /* we have a plain text passphrase - create a DEK from it.
2122          * It is a little bit ridiculous to keep it ih secure memory
2123          * but becuase we do this alwasy, why not here */
2124         STRING2KEY *s2k;
2125         DEK *dek;
2126
2127         s2k = xmalloc_secure( sizeof *s2k );
2128         s2k->mode = opt.s2k_mode;
2129         s2k->hash_algo = S2K_DIGEST_ALGO;
2130         set_next_passphrase( r->u.value );
2131         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2132                                  NULL, NULL);
2133         set_next_passphrase( NULL );
2134         assert( dek );
2135         memset( r->u.value, 0, strlen(r->u.value) );
2136
2137         r = xmalloc_clear( sizeof *r );
2138         r->key = pPASSPHRASE_S2K;
2139         r->u.s2k = s2k;
2140         r->next = para;
2141         para = r;
2142         r = xmalloc_clear( sizeof *r );
2143         r->key = pPASSPHRASE_DEK;
2144         r->u.dek = dek;
2145         r->next = para;
2146         para = r;
2147     }
2148
2149     /* make KEYEXPIRE from Expire-Date */
2150     r = get_parameter( para, pEXPIREDATE );
2151     if( r && *r->u.value )
2152       {
2153         u32 seconds;
2154
2155         seconds = parse_expire_string( r->u.value );
2156         if( seconds == (u32)-1 )
2157           {
2158             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2159             return -1;
2160           }
2161         r->u.expire = seconds;
2162         r->key = pKEYEXPIRE;  /* change hat entry */
2163         /* also set it for the subkey */
2164         r = xmalloc_clear( sizeof *r + 20 );
2165         r->key = pSUBKEYEXPIRE;
2166         r->u.expire = seconds;
2167         r->next = para;
2168         para = r;
2169       }
2170
2171     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2172         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2173         return -1;
2174     }
2175
2176     do_generate_keypair( para, outctrl, card );
2177     return 0;
2178 }
2179
2180
2181 /****************
2182  * Kludge to allow non interactive key generation controlled
2183  * by a parameter file.
2184  * Note, that string parameters are expected to be in UTF-8
2185  */
2186 static void
2187 read_parameter_file( const char *fname )
2188 {
2189     static struct { const char *name;
2190                     enum para_name key;
2191     } keywords[] = {
2192         { "Key-Type",       pKEYTYPE},
2193         { "Key-Length",     pKEYLENGTH },
2194         { "Key-Usage",      pKEYUSAGE },
2195         { "Subkey-Type",    pSUBKEYTYPE },
2196         { "Subkey-Length",  pSUBKEYLENGTH },
2197         { "Subkey-Usage",   pSUBKEYUSAGE },
2198         { "Name-Real",      pNAMEREAL },
2199         { "Name-Email",     pNAMEEMAIL },
2200         { "Name-Comment",   pNAMECOMMENT },
2201         { "Expire-Date",    pEXPIREDATE },
2202         { "Passphrase",     pPASSPHRASE },
2203         { "Preferences",    pPREFERENCES },
2204         { "Revoker",        pREVOKER },
2205         { "Handle",         pHANDLE },
2206         { NULL, 0 }
2207     };
2208     IOBUF fp;
2209     byte *line;
2210     unsigned int maxlen, nline;
2211     char *p;
2212     int lnr;
2213     const char *err = NULL;
2214     struct para_data_s *para, *r;
2215     int i;
2216     struct output_control_s outctrl;
2217
2218     memset( &outctrl, 0, sizeof( outctrl ) );
2219
2220     if( !fname || !*fname)
2221       fname = "-";
2222
2223     fp = iobuf_open (fname);
2224     if (fp && is_secured_file (iobuf_get_fd (fp)))
2225       {
2226         iobuf_close (fp);
2227         fp = NULL;
2228         errno = EPERM;
2229       }
2230     if (!fp) {
2231       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2232       return;
2233     }
2234     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2235
2236     lnr = 0;
2237     err = NULL;
2238     para = NULL;
2239     maxlen = 1024;
2240     line = NULL;
2241     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2242         char *keyword, *value;
2243
2244         lnr++;
2245         if( !maxlen ) {
2246             err = "line too long";
2247             break;
2248         }
2249         for( p = line; isspace(*(byte*)p); p++ )
2250             ;
2251         if( !*p || *p == '#' )
2252             continue;
2253         keyword = p;
2254         if( *keyword == '%' ) {
2255             for( ; !isspace(*(byte*)p); p++ )
2256                 ;
2257             if( *p )
2258                 *p++ = 0;
2259             for( ; isspace(*(byte*)p); p++ )
2260                 ;
2261             value = p;
2262             trim_trailing_ws( value, strlen(value) );
2263             if( !ascii_strcasecmp( keyword, "%echo" ) )
2264                 log_info("%s\n", value );
2265             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2266                 outctrl.dryrun = 1;
2267             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2268                 outctrl.lnr = lnr;
2269                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2270                   print_status_key_not_created 
2271                     (get_parameter_value (para, pHANDLE));
2272                 release_parameter_list( para );
2273                 para = NULL;
2274             }
2275             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2276                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2277                     ; /* still the same file - ignore it */
2278                 else {
2279                     xfree( outctrl.pub.newfname );
2280                     outctrl.pub.newfname = xstrdup( value );
2281                     outctrl.use_files = 1;
2282                 }
2283             }
2284             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2285                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2286                     ; /* still the same file - ignore it */
2287                 else {
2288                    xfree( outctrl.sec.newfname );
2289                    outctrl.sec.newfname = xstrdup( value );
2290                    outctrl.use_files = 1;
2291                 }
2292             }
2293             else
2294                 log_info("skipping control `%s' (%s)\n", keyword, value );
2295
2296
2297             continue;
2298         }
2299
2300
2301         if( !(p = strchr( p, ':' )) || p == keyword ) {
2302             err = "missing colon";
2303             break;
2304         }
2305         if( *p )
2306             *p++ = 0;
2307         for( ; isspace(*(byte*)p); p++ )
2308             ;
2309         if( !*p ) {
2310             err = "missing argument";
2311             break;
2312         }
2313         value = p;
2314         trim_trailing_ws( value, strlen(value) );
2315
2316         for(i=0; keywords[i].name; i++ ) {
2317             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2318                 break;
2319         }
2320         if( !keywords[i].name ) {
2321             err = "unknown keyword";
2322             break;
2323         }
2324         if( keywords[i].key != pKEYTYPE && !para ) {
2325             err = "parameter block does not start with \"Key-Type\"";
2326             break;
2327         }
2328
2329         if( keywords[i].key == pKEYTYPE && para ) {
2330             outctrl.lnr = lnr;
2331             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2332               print_status_key_not_created
2333                 (get_parameter_value (para, pHANDLE));
2334             release_parameter_list( para );
2335             para = NULL;
2336         }
2337         else {
2338             for( r = para; r; r = r->next ) {
2339                 if( r->key == keywords[i].key )
2340                     break;
2341             }
2342             if( r ) {
2343                 err = "duplicate keyword";
2344                 break;
2345             }
2346         }
2347         r = xmalloc_clear( sizeof *r + strlen( value ) );
2348         r->lnr = lnr;
2349         r->key = keywords[i].key;
2350         strcpy( r->u.value, value );
2351         r->next = para;
2352         para = r;
2353     }
2354     if( err )
2355         log_error("%s:%d: %s\n", fname, lnr, err );
2356     else if( iobuf_error (fp) ) {
2357         log_error("%s:%d: read error\n", fname, lnr);
2358     }
2359     else if( para ) {
2360         outctrl.lnr = lnr;
2361         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2362           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2363     }
2364
2365     if( outctrl.use_files ) { /* close open streams */
2366         iobuf_close( outctrl.pub.stream );
2367         iobuf_close( outctrl.sec.stream );
2368
2369         /* Must invalidate that ugly cache to actually close it.  */
2370         if (outctrl.pub.fname)
2371           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2372         if (outctrl.sec.fname)
2373           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2374
2375         xfree( outctrl.pub.fname );
2376         xfree( outctrl.pub.newfname );
2377         xfree( outctrl.sec.fname );
2378         xfree( outctrl.sec.newfname );
2379     }
2380
2381     release_parameter_list( para );
2382     iobuf_close (fp);
2383 }
2384
2385
2386 /*
2387  * Generate a keypair (fname is only used in batch mode) If
2388  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2389  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2390  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2391  * generate in software, imported to the card and a backup file
2392  * written to directory given by this argument .
2393  */
2394 void
2395 generate_keypair (const char *fname, const char *card_serialno, 
2396                   const char *backup_encryption_dir)
2397 {
2398   unsigned int nbits;
2399   char *uid = NULL;
2400   DEK *dek;
2401   STRING2KEY *s2k;
2402   int algo;
2403   unsigned int use;
2404   int both = 0;
2405   u32 expire;
2406   struct para_data_s *para = NULL;
2407   struct para_data_s *r;
2408   struct output_control_s outctrl;
2409   
2410   memset( &outctrl, 0, sizeof( outctrl ) );
2411   
2412   if (opt.batch && card_serialno)
2413     {
2414       /* We don't yet support unattended key generation. */
2415       log_error (_("can't do this in batch mode\n"));
2416       return;
2417     }
2418   
2419   if (opt.batch)
2420     {
2421       read_parameter_file( fname );
2422       return;
2423     }
2424
2425   if (card_serialno)
2426     {
2427 #ifdef ENABLE_CARD_SUPPORT
2428       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2429       r->key = pSERIALNO;
2430       strcpy( r->u.value, card_serialno);
2431       r->next = para;
2432       para = r;
2433        
2434       algo = PUBKEY_ALGO_RSA;
2435        
2436       r = xcalloc (1, sizeof *r + 20 );
2437       r->key = pKEYTYPE;
2438       sprintf( r->u.value, "%d", algo );
2439       r->next = para;
2440       para = r;
2441       r = xcalloc (1, sizeof *r + 20 );
2442       r->key = pKEYUSAGE;
2443       strcpy (r->u.value, "sign");
2444       r->next = para;
2445       para = r;
2446        
2447       r = xcalloc (1, sizeof *r + 20 );
2448       r->key = pSUBKEYTYPE;
2449       sprintf( r->u.value, "%d", algo );
2450       r->next = para;
2451       para = r;
2452       r = xcalloc (1, sizeof *r + 20 );
2453       r->key = pSUBKEYUSAGE;
2454       strcpy (r->u.value, "encrypt");
2455       r->next = para;
2456       para = r;
2457        
2458       r = xcalloc (1, sizeof *r + 20 );
2459       r->key = pAUTHKEYTYPE;
2460       sprintf( r->u.value, "%d", algo );
2461       r->next = para;
2462       para = r;
2463
2464       if (backup_encryption_dir)
2465         {
2466           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2467           r->key = pBACKUPENCDIR;
2468           strcpy (r->u.value, backup_encryption_dir);
2469           r->next = para;
2470           para = r;
2471         }
2472 #endif /*ENABLE_CARD_SUPPORT*/
2473     }
2474   else
2475     {
2476       algo = ask_algo( 0, &use );
2477       if( !algo )
2478         { /* default: DSA with ElG subkey of the specified size */
2479           both = 1;
2480           r = xmalloc_clear( sizeof *r + 20 );
2481           r->key = pKEYTYPE;
2482           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2483           r->next = para;
2484           para = r;
2485           tty_printf(_("DSA keypair will have %u bits.\n"),1024);
2486           r = xmalloc_clear( sizeof *r + 20 );
2487           r->key = pKEYLENGTH;
2488           strcpy( r->u.value, "1024" );
2489           r->next = para;
2490           para = r;
2491           r = xmalloc_clear( sizeof *r + 20 );
2492           r->key = pKEYUSAGE;
2493           strcpy( r->u.value, "sign" );
2494           r->next = para;
2495           para = r;
2496            
2497           algo = PUBKEY_ALGO_ELGAMAL_E;
2498           r = xmalloc_clear( sizeof *r + 20 );
2499           r->key = pSUBKEYTYPE;
2500           sprintf( r->u.value, "%d", algo );
2501           r->next = para;
2502           para = r;
2503           r = xmalloc_clear( sizeof *r + 20 );
2504           r->key = pSUBKEYUSAGE;
2505           strcpy( r->u.value, "encrypt" );
2506           r->next = para;
2507           para = r;
2508         }
2509       else 
2510         {
2511           r = xmalloc_clear( sizeof *r + 20 );
2512           r->key = pKEYTYPE;
2513           sprintf( r->u.value, "%d", algo );
2514           r->next = para;
2515           para = r;
2516            
2517           if (use)
2518             {
2519               r = xmalloc_clear( sizeof *r + 25 );
2520               r->key = pKEYUSAGE;
2521               sprintf( r->u.value, "%s%s%s",
2522                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2523                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
2524                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
2525               r->next = para;
2526               para = r;
2527             }
2528            
2529         }
2530        
2531       nbits = ask_keysize( algo );
2532       r = xmalloc_clear( sizeof *r + 20 );
2533       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2534       sprintf( r->u.value, "%u", nbits);
2535       r->next = para;
2536       para = r;
2537     }
2538    
2539   expire = ask_expire_interval(0,NULL);
2540   r = xmalloc_clear( sizeof *r + 20 );
2541   r->key = pKEYEXPIRE;
2542   r->u.expire = expire;
2543   r->next = para;
2544   para = r;
2545   r = xmalloc_clear( sizeof *r + 20 );
2546   r->key = pSUBKEYEXPIRE;
2547   r->u.expire = expire;
2548   r->next = para;
2549   para = r;
2550
2551   uid = ask_user_id(0);
2552   if( !uid ) 
2553     {
2554       log_error(_("Key generation canceled.\n"));
2555       release_parameter_list( para );
2556       return;
2557     }
2558   r = xmalloc_clear( sizeof *r + strlen(uid) );
2559   r->key = pUSERID;
2560   strcpy( r->u.value, uid );
2561   r->next = para;
2562   para = r;
2563     
2564   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2565   if( dek )
2566     {
2567       r = xmalloc_clear( sizeof *r );
2568       r->key = pPASSPHRASE_DEK;
2569       r->u.dek = dek;
2570       r->next = para;
2571       para = r;
2572       r = xmalloc_clear( sizeof *r );
2573       r->key = pPASSPHRASE_S2K;
2574       r->u.s2k = s2k;
2575       r->next = para;
2576       para = r;
2577     }
2578     
2579   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2580   release_parameter_list( para );
2581 }
2582
2583
2584 #ifdef ENABLE_CARD_SUPPORT
2585 /* Generate a raw key and return it as a secret key packet.  The
2586    function will ask for the passphrase and return a protected as well
2587    as an unprotected copy of a new secret key packet.  0 is returned
2588    on success and the caller must then free the returned values.  */
2589 static int
2590 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
2591                   PKT_secret_key **r_sk_unprotected,
2592                   PKT_secret_key **r_sk_protected)
2593 {
2594   int rc;
2595   DEK *dek = NULL;
2596   STRING2KEY *s2k = NULL;
2597   PKT_secret_key *sk = NULL;
2598   int i;
2599   size_t nskey, npkey;
2600
2601   npkey = pubkey_get_npkey (algo);
2602   nskey = pubkey_get_nskey (algo);
2603   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
2604
2605   if (nbits < 512)
2606     {
2607       nbits = 512;
2608       log_info (_("keysize invalid; using %u bits\n"), nbits );
2609     }
2610
2611   if ((nbits % 32)) 
2612     {
2613       nbits = ((nbits + 31) / 32) * 32;
2614       log_info(_("keysize rounded up to %u bits\n"), nbits );
2615     }
2616
2617   dek = do_ask_passphrase (&s2k);
2618
2619   sk = xmalloc_clear (sizeof *sk);
2620   sk->timestamp = created_at;
2621   sk->version = 4;
2622   sk->pubkey_algo = algo;
2623
2624   rc = pubkey_generate (algo, nbits, sk->skey, NULL);
2625   if (rc)
2626     {
2627       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
2628       goto leave;
2629     }
2630
2631   for (i=npkey; i < nskey; i++)
2632     sk->csum += checksum_mpi (sk->skey[i]);
2633
2634   if (r_sk_unprotected) 
2635     *r_sk_unprotected = copy_secret_key (NULL, sk);
2636
2637   if (dek)
2638     {
2639       sk->protect.algo = dek->algo;
2640       sk->protect.s2k = *s2k;
2641       rc = protect_secret_key (sk, dek);
2642       if (rc)
2643         {
2644           log_error ("protect_secret_key failed: %s\n", g10_errstr(rc));
2645           goto leave;
2646         }
2647     }
2648   if (r_sk_protected)
2649     {
2650       *r_sk_protected = sk;
2651       sk = NULL;
2652     }
2653
2654  leave:
2655   if (sk)
2656     free_secret_key (sk);
2657   xfree (dek);
2658   xfree (s2k);
2659   return rc;
2660 }
2661 #endif /* ENABLE_CARD_SUPPORT */
2662
2663 /* Create and delete a dummy packet to start off a list of kbnodes. */
2664 static void
2665 start_tree(KBNODE *tree)
2666 {
2667   PACKET *pkt;
2668
2669   pkt=xmalloc_clear(sizeof(*pkt));
2670
2671   /* We're not acually using a user ID here - this is just an
2672      arbitrary choice.  We delete it anyway. */
2673
2674   pkt->pkttype=PKT_USER_ID;
2675   pkt->pkt.user_id=xmalloc_clear(sizeof *pkt->pkt.user_id);
2676   pkt->pkt.user_id->ref=1;
2677
2678   *tree=new_kbnode(pkt);
2679   delete_kbnode(*tree);
2680 }
2681
2682 static void
2683 do_generate_keypair( struct para_data_s *para,
2684                      struct output_control_s *outctrl, int card )
2685 {
2686     KBNODE pub_root = NULL;
2687     KBNODE sec_root = NULL;
2688     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2689     const char *s;
2690     struct revocation_key *revkey;
2691     int rc;
2692     int did_sub = 0;
2693
2694     if( outctrl->dryrun )
2695       {
2696         log_info("dry-run mode - key generation skipped\n");
2697         return;
2698       }
2699
2700     if( outctrl->use_files ) {
2701         if( outctrl->pub.newfname ) {
2702             iobuf_close(outctrl->pub.stream);
2703             outctrl->pub.stream = NULL;
2704             if (outctrl->pub.fname)
2705               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
2706             xfree( outctrl->pub.fname );
2707             outctrl->pub.fname =  outctrl->pub.newfname;
2708             outctrl->pub.newfname = NULL;
2709
2710             if (is_secured_filename (outctrl->pub.fname) ) {
2711                 outctrl->pub.stream = NULL;
2712                 errno = EPERM;
2713             }
2714             else
2715                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2716             if( !outctrl->pub.stream ) {
2717                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
2718                                                      strerror(errno) );
2719                 return;
2720             }
2721             if( opt.armor ) {
2722                 outctrl->pub.afx.what = 1;
2723                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2724                                                     &outctrl->pub.afx );
2725             }
2726         }
2727         if( outctrl->sec.newfname ) {
2728             mode_t oldmask;
2729
2730             iobuf_close(outctrl->sec.stream);
2731             outctrl->sec.stream = NULL;
2732             if (outctrl->sec.fname)
2733               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
2734             xfree( outctrl->sec.fname );
2735             outctrl->sec.fname =  outctrl->sec.newfname;
2736             outctrl->sec.newfname = NULL;
2737
2738             oldmask = umask (077);
2739             if (is_secured_filename (outctrl->sec.fname) ) {
2740                 outctrl->sec.stream = NULL;
2741                 errno = EPERM;
2742             }
2743             else
2744                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2745             umask (oldmask);
2746             if( !outctrl->sec.stream ) {
2747                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
2748                                                      strerror(errno) );
2749                 return;
2750             }
2751             if( opt.armor ) {
2752                 outctrl->sec.afx.what = 5;
2753                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2754                                                     &outctrl->sec.afx );
2755             }
2756         }
2757         assert( outctrl->pub.stream );
2758         assert( outctrl->sec.stream );
2759         if( opt.verbose ) {
2760             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2761             if (card)
2762               log_info (_("writing secret key stub to `%s'\n"),
2763                         outctrl->sec.fname);
2764             else
2765               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2766         }
2767     }
2768
2769
2770     /* we create the packets as a tree of kbnodes. Because the
2771      * structure we create is known in advance we simply generate a
2772      * linked list.  The first packet is a dummy packet which we flag
2773      * as deleted.  The very first packet must always be a KEY packet.
2774      */
2775     
2776     start_tree(&pub_root);
2777     start_tree(&sec_root);
2778
2779     if (!card)
2780       {
2781         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2782                         get_parameter_uint( para, pKEYLENGTH ),
2783                         pub_root, sec_root,
2784                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2785                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2786                         &pri_sk,
2787                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
2788       }
2789     else
2790       {
2791         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root,
2792                            get_parameter_u32 (para, pKEYEXPIRE), para);
2793         if (!rc)
2794           {
2795             pri_sk = sec_root->next->pkt->pkt.secret_key;
2796             assert (pri_sk);
2797           }
2798       }
2799
2800     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2801       {
2802         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
2803         if(!rc)
2804           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
2805       }
2806
2807     if( !rc && (s=get_parameter_value(para, pUSERID)) )
2808       {
2809         write_uid(pub_root, s );
2810         if( !rc )
2811           write_uid(sec_root, s );
2812
2813         if( !rc )
2814           rc = write_selfsigs(sec_root, pub_root, pri_sk,
2815                               get_parameter_uint (para, pKEYUSAGE));
2816       }
2817
2818     /* Write the auth key to the card before the encryption key.  This
2819        is a partial workaround for a PGP bug (as of this writing, all
2820        versions including 8.1), that causes it to try and encrypt to
2821        the most recent subkey regardless of whether that subkey is
2822        actually an encryption type.  In this case, the auth key is an
2823        RSA key so it succeeds. */
2824
2825     if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
2826       {
2827         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root,
2828                            get_parameter_u32 (para, pKEYEXPIRE), para);
2829         
2830         if (!rc)
2831           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2832         if (!rc)
2833           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2834       }
2835
2836     if( !rc && get_parameter( para, pSUBKEYTYPE ) )
2837       {
2838         if (!card)
2839           {
2840             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2841                             get_parameter_uint( para, pSUBKEYLENGTH ),
2842                             pub_root, sec_root,
2843                             get_parameter_dek( para, pPASSPHRASE_DEK ),
2844                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
2845                             &sub_sk,
2846                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
2847           }
2848         else
2849           {
2850             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
2851               {
2852                 /* A backup of the encryption key has been requested.
2853                    Generate the key i software and import it then to
2854                    the card.  Write a backup file. */
2855                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
2856                                                pub_root, sec_root,
2857                                                get_parameter_u32 (para,
2858                                                                   pKEYEXPIRE),
2859                                                para, s);
2860               }
2861             else
2862               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
2863                                  get_parameter_u32 (para, pKEYEXPIRE), para);
2864           }
2865
2866         if( !rc )
2867           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
2868                                 get_parameter_uint (para, pSUBKEYUSAGE));
2869         if( !rc )
2870           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
2871                                 get_parameter_uint (para, pSUBKEYUSAGE));
2872         did_sub = 1;
2873       }
2874
2875     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2876         rc = write_keyblock( outctrl->pub.stream, pub_root );
2877         if( rc )
2878             log_error("can't write public key: %s\n", g10_errstr(rc) );
2879         if( !rc ) {
2880             rc = write_keyblock( outctrl->sec.stream, sec_root );
2881             if( rc )
2882                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2883         }
2884
2885     }
2886     else if( !rc ) { /* write to the standard keyrings */
2887         KEYDB_HANDLE pub_hd = keydb_new (0);
2888         KEYDB_HANDLE sec_hd = keydb_new (1);
2889
2890         /* FIXME: we may have to create the keyring first */
2891         rc = keydb_locate_writable (pub_hd, NULL);
2892         if (rc) 
2893             log_error (_("no writable public keyring found: %s\n"),
2894                        g10_errstr (rc));
2895
2896         if (!rc) {  
2897             rc = keydb_locate_writable (sec_hd, NULL);
2898             if (rc) 
2899                 log_error (_("no writable secret keyring found: %s\n"),
2900                            g10_errstr (rc));
2901         }
2902
2903         if (!rc && opt.verbose) {
2904             log_info(_("writing public key to `%s'\n"),
2905                      keydb_get_resource_name (pub_hd));
2906             if (card)
2907               log_info (_("writing secret key stub to `%s'\n"),
2908                         keydb_get_resource_name (sec_hd));
2909             else
2910               log_info(_("writing secret key to `%s'\n"),
2911                        keydb_get_resource_name (sec_hd));
2912         }
2913
2914         if (!rc) {
2915             rc = keydb_insert_keyblock (pub_hd, pub_root);
2916             if (rc)
2917                 log_error (_("error writing public keyring `%s': %s\n"),
2918                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2919         }
2920
2921         if (!rc) {
2922             rc = keydb_insert_keyblock (sec_hd, sec_root);
2923             if (rc)
2924                 log_error (_("error writing secret keyring `%s': %s\n"),
2925                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2926         }
2927
2928         keydb_release (pub_hd);
2929         keydb_release (sec_hd);
2930
2931         if (!rc) {
2932             int no_enc_rsa =
2933                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2934                 && get_parameter_uint( para, pKEYUSAGE )
2935                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2936             PKT_public_key *pk = find_kbnode (pub_root, 
2937                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2938
2939             keyid_from_pk(pk,pk->main_keyid);
2940             register_trusted_keyid(pk->main_keyid);
2941
2942             update_ownertrust (pk,
2943                                ((get_ownertrust (pk) & ~TRUST_MASK)
2944                                 | TRUST_ULTIMATE ));
2945
2946             if (!opt.batch) {
2947                 tty_printf(_("public and secret key created and signed.\n") );
2948                 tty_printf("\n");
2949                 list_keyblock(pub_root,0,1,NULL);
2950             }
2951             
2952
2953             if( !opt.batch
2954                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2955                      || no_enc_rsa )
2956                 && !get_parameter( para, pSUBKEYTYPE ) )
2957             {
2958                 tty_printf(_("Note that this key cannot be used for "
2959                              "encryption.  You may want to use\n"
2960                              "the command \"--edit-key\" to generate a "
2961                              "subkey for this purpose.\n") );
2962             }
2963         }
2964     }
2965
2966     if( rc ) {
2967         if( opt.batch )
2968             log_error("key generation failed: %s\n", g10_errstr(rc) );
2969         else
2970             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2971         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
2972     }
2973     else {
2974         PKT_public_key *pk = find_kbnode (pub_root, 
2975                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2976         print_status_key_created (did_sub? 'B':'P', pk,
2977                                   get_parameter_value (para, pHANDLE));
2978     }
2979     release_kbnode( pub_root );
2980     release_kbnode( sec_root );
2981
2982     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
2983       free_secret_key(pri_sk); /* shallow copy in card mode. */
2984     if( sub_sk )
2985         free_secret_key(sub_sk);
2986 }
2987
2988
2989 /****************
2990  * add a new subkey to an existing key.
2991  * Returns true if a new key has been generated and put into the keyblocks.
2992  */
2993 int
2994 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2995 {
2996     int okay=0, rc=0;
2997     KBNODE node;
2998     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2999     int algo;
3000     unsigned int use;
3001     u32 expire;
3002     unsigned nbits;
3003     char *passphrase = NULL;
3004     DEK *dek = NULL;
3005     STRING2KEY *s2k = NULL;
3006     u32 cur_time;
3007     int ask_pass = 0;
3008
3009     /* break out the primary secret key */
3010     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3011     if( !node ) {
3012         log_error("Oops; secret key not found anymore!\n");
3013         goto leave;
3014     }
3015
3016     /* make a copy of the sk to keep the protected one in the keyblock */
3017     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
3018
3019     cur_time = make_timestamp();
3020     if( pri_sk->timestamp > cur_time ) {
3021         ulong d = pri_sk->timestamp - cur_time;
3022         log_info( d==1 ? _("key has been created %lu second "
3023                            "in future (time warp or clock problem)\n")
3024                        : _("key has been created %lu seconds "
3025                            "in future (time warp or clock problem)\n"), d );
3026         if( !opt.ignore_time_conflict ) {
3027             rc = G10ERR_TIME_CONFLICT;
3028             goto leave;
3029         }
3030     }
3031
3032     if (pri_sk->version < 4) {
3033         log_info (_("NOTE: creating subkeys for v3 keys "
3034                     "is not OpenPGP compliant\n"));
3035         goto leave;
3036     }
3037
3038     if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) {
3039         tty_printf(_("Secret parts of primary key are not available.\n"));
3040         rc = G10ERR_NO_SECKEY;
3041         goto leave;
3042     }
3043
3044
3045     /* Unprotect to get the passphrase.  */
3046     switch( is_secret_key_protected( pri_sk ) ) {
3047       case -1:
3048         rc = G10ERR_PUBKEY_ALGO;
3049         break;
3050       case 0:
3051         tty_printf(_("This key is not protected.\n"));
3052         break;
3053       case -2:
3054         tty_printf(_("Secret parts of primary key are stored on-card.\n"));
3055         ask_pass = 1;
3056         break;
3057       default:
3058         tty_printf(_("Key is protected.\n"));
3059         rc = check_secret_key( pri_sk, 0 );
3060         if( !rc )
3061             passphrase = get_last_passphrase();
3062         break;
3063     }
3064     if( rc )
3065         goto leave;
3066
3067     algo = ask_algo( 1, &use );
3068     assert(algo);
3069     nbits = ask_keysize( algo );
3070     expire = ask_expire_interval(0,NULL);
3071     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3072                                                   _("Really create? (y/N) ")))
3073         goto leave;
3074
3075     if (ask_pass)
3076         dek = do_ask_passphrase (&s2k);
3077     else if (passphrase) {
3078         s2k = xmalloc_secure( sizeof *s2k );
3079         s2k->mode = opt.s2k_mode;
3080         s2k->hash_algo = S2K_DIGEST_ALGO;
3081         set_next_passphrase( passphrase );
3082         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3083                                  NULL, NULL );
3084     }
3085
3086     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
3087                                       dek, s2k, &sub_sk, expire, 1 );
3088     if( !rc )
3089         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3090     if( !rc )
3091         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3092     if( !rc ) {
3093         okay = 1;
3094         write_status_text (STATUS_KEY_CREATED, "S");
3095     }
3096
3097   leave:
3098     if( rc )
3099         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3100     xfree( passphrase );
3101     xfree( dek );
3102     xfree( s2k );
3103     /* release the copy of the (now unprotected) secret keys */
3104     if( pri_sk )
3105         free_secret_key(pri_sk);
3106     if( sub_sk )
3107         free_secret_key(sub_sk);
3108     set_next_passphrase( NULL );
3109     return okay;
3110 }
3111
3112
3113 #ifdef ENABLE_CARD_SUPPORT
3114 /* Generate a subkey on a card. */
3115 int
3116 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3117                           int keyno, const char *serialno)
3118 {
3119   int okay=0, rc=0;
3120   KBNODE node;
3121   PKT_secret_key *pri_sk = NULL;
3122   int algo;
3123   unsigned int use;
3124   u32 expire;
3125   char *passphrase = NULL;
3126   u32 cur_time;
3127   struct para_data_s *para = NULL;
3128
3129   assert (keyno >= 1 && keyno <= 3);
3130
3131   para = xcalloc (1, sizeof *para + strlen (serialno) );
3132   para->key = pSERIALNO;
3133   strcpy (para->u.value, serialno);
3134
3135   /* Break out the primary secret key */
3136   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3137   if(!node)
3138     {
3139       log_error("Oops; secret key not found anymore!\n");
3140       goto leave;
3141     }
3142
3143   /* Make a copy of the sk to keep the protected one in the keyblock */
3144   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3145
3146   cur_time = make_timestamp();
3147   if (pri_sk->timestamp > cur_time)
3148     {
3149       ulong d = pri_sk->timestamp - cur_time;
3150       log_info (d==1 ? _("key has been created %lu second "
3151                          "in future (time warp or clock problem)\n")
3152                      : _("key has been created %lu seconds "
3153                          "in future (time warp or clock problem)\n"), d );
3154         if (!opt.ignore_time_conflict)
3155           {
3156             rc = G10ERR_TIME_CONFLICT;
3157             goto leave;
3158           }
3159     }
3160
3161   if (pri_sk->version < 4)
3162     {
3163       log_info (_("NOTE: creating subkeys for v3 keys "
3164                   "is not OpenPGP compliant\n"));
3165       goto leave;
3166     }
3167
3168   /* Unprotect to get the passphrase. */
3169   switch( is_secret_key_protected (pri_sk) )
3170     {
3171     case -1:
3172       rc = G10ERR_PUBKEY_ALGO;
3173       break;
3174     case 0:
3175       tty_printf("This key is not protected.\n");
3176       break;
3177     default:
3178       tty_printf("Key is protected.\n");
3179       rc = check_secret_key( pri_sk, 0 );
3180       if (!rc)
3181         passphrase = get_last_passphrase();
3182       break;
3183     }
3184   if (rc)
3185     goto leave;
3186
3187   algo = PUBKEY_ALGO_RSA;
3188   expire = ask_expire_interval (0,NULL);
3189   if (keyno == 1)
3190     use = PUBKEY_USAGE_SIG;
3191   else if (keyno == 2)
3192     use = PUBKEY_USAGE_ENC;
3193   else
3194     use = PUBKEY_USAGE_AUTH;
3195   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3196                                                _("Really create? (y/N) ")))
3197     goto leave;
3198
3199   if (passphrase)
3200     set_next_passphrase (passphrase);
3201   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock, expire, para);
3202   if (!rc)
3203     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, NULL, use);
3204   if (!rc)
3205     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, NULL, use);
3206   if (!rc)
3207     {
3208       okay = 1;
3209       write_status_text (STATUS_KEY_CREATED, "S");
3210     }
3211
3212  leave:
3213   if (rc)
3214     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3215   xfree (passphrase);
3216   /* Release the copy of the (now unprotected) secret keys. */
3217   if (pri_sk)
3218     free_secret_key (pri_sk);
3219   set_next_passphrase( NULL );
3220   release_parameter_list (para);
3221   return okay;
3222 }
3223 #endif /* !ENABLE_CARD_SUPPORT */
3224
3225
3226 /****************
3227  * Write a keyblock to an output stream
3228  */
3229 static int
3230 write_keyblock( IOBUF out, KBNODE node )
3231 {
3232     for( ; node ; node = node->next ) {
3233         int rc = build_packet( out, node->pkt );
3234         if( rc ) {
3235             log_error("build_packet(%d) failed: %s\n",
3236                         node->pkt->pkttype, g10_errstr(rc) );
3237             return G10ERR_WRITE_FILE;
3238         }
3239     }
3240     return 0;
3241 }
3242
3243
3244 static int
3245 gen_card_key (int algo, int keyno, int is_primary,
3246               KBNODE pub_root, KBNODE sec_root,
3247               u32 expireval, struct para_data_s *para)
3248 {
3249 #ifdef ENABLE_CARD_SUPPORT
3250   int rc;
3251   const char *s;
3252   struct agent_card_genkey_s info;
3253   PACKET *pkt;
3254   PKT_secret_key *sk;
3255   PKT_public_key *pk;
3256
3257   assert (algo == PUBKEY_ALGO_RSA);
3258   
3259
3260   rc = agent_scd_genkey (&info, keyno, 1);
3261 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3262 /*      { */
3263 /*        tty_printf ("\n"); */
3264 /*        log_error ("WARNING: key does already exists!\n"); */
3265 /*        tty_printf ("\n"); */
3266 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3267 /*                                    _("Replace existing key? "))) */
3268 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3269 /*      } */
3270
3271   if (rc)
3272     {
3273       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3274       return rc;
3275     }
3276   if ( !info.n || !info.e )
3277     {
3278       log_error ("communication error with SCD\n");
3279       mpi_free (info.n);
3280       mpi_free (info.e);
3281       return gpg_error (GPG_ERR_GENERAL);
3282     }
3283   
3284
3285   pk = xcalloc (1, sizeof *pk );
3286   sk = xcalloc (1, sizeof *sk );
3287   sk->timestamp = pk->timestamp = info.created_at;
3288   sk->version = pk->version = 4;
3289   if (expireval)
3290       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3291   sk->pubkey_algo = pk->pubkey_algo = algo;
3292   pk->pkey[0] = info.n;
3293   pk->pkey[1] = info.e; 
3294   sk->skey[0] = mpi_copy (pk->pkey[0]);
3295   sk->skey[1] = mpi_copy (pk->pkey[1]);
3296   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3297   sk->is_protected = 1;
3298   sk->protect.s2k.mode = 1002;
3299   s = get_parameter_value (para, pSERIALNO);
3300   if (s)
3301     {
3302       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3303            sk->protect.ivlen++, s += 2)
3304         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3305     }
3306
3307   pkt = xcalloc (1,sizeof *pkt);
3308   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3309   pkt->pkt.public_key = pk;
3310   add_kbnode(pub_root, new_kbnode( pkt ));
3311
3312   pkt = xcalloc (1,sizeof *pkt);
3313   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3314   pkt->pkt.secret_key = sk;
3315   add_kbnode(sec_root, new_kbnode( pkt ));
3316
3317   return 0;
3318 #else
3319   return -1;
3320 #endif /*!ENABLE_CARD_SUPPORT*/
3321 }
3322
3323
3324
3325 static int
3326 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3327                           KBNODE pub_root, KBNODE sec_root,
3328                           u32 expireval, struct para_data_s *para,
3329                           const char *backup_dir)
3330 {
3331 #ifdef ENABLE_CARD_SUPPORT
3332   int rc;
3333   const char *s;
3334   PACKET *pkt;
3335   PKT_secret_key *sk, *sk_unprotected, *sk_protected;
3336   PKT_public_key *pk;
3337   size_t n;
3338   int i;
3339
3340   rc = generate_raw_key (algo, 1024, make_timestamp (),
3341                          &sk_unprotected, &sk_protected);
3342   if (rc)
3343     return rc;
3344
3345   /* First, store the key to the card. */
3346   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3347   if (rc)
3348     {
3349       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3350       free_secret_key (sk_unprotected);
3351       free_secret_key (sk_protected);
3352       return rc;
3353     }
3354
3355   /* Get rid of the secret key parameters and store the serial numer. */
3356   sk = sk_unprotected;
3357   n = pubkey_get_nskey (sk->pubkey_algo);
3358   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3359     {
3360       mpi_free (sk->skey[i]);
3361       sk->skey[i] = NULL;
3362     }
3363   i = pubkey_get_npkey (sk->pubkey_algo);
3364   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3365   sk->is_protected = 1;
3366   sk->protect.s2k.mode = 1002;
3367   s = get_parameter_value (para, pSERIALNO);
3368   assert (s);
3369   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3370        sk->protect.ivlen++, s += 2)
3371     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3372
3373   /* Now write the *protected* secret key to the file.  */
3374   {
3375     char name_buffer[50];
3376     char *fname;
3377     IOBUF fp;
3378     mode_t oldmask;
3379
3380     keyid_from_sk (sk, NULL);
3381     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
3382              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3383
3384     fname = make_filename (backup_dir, name_buffer, NULL);
3385     oldmask = umask (077);
3386     if (is_secured_filename (fname))
3387       {
3388         fp = NULL;
3389         errno = EPERM;
3390       }
3391     else
3392       fp = iobuf_create (fname);
3393     umask (oldmask);
3394     if (!fp) 
3395       {
3396         log_error (_("can't create backup file `%s': %s\n"),
3397                    fname, strerror(errno) );
3398         xfree (fname);
3399         free_secret_key (sk_unprotected);
3400         free_secret_key (sk_protected);
3401         return G10ERR_OPEN_FILE;
3402       }
3403
3404     pkt = xcalloc (1, sizeof *pkt);
3405     pkt->pkttype = PKT_SECRET_KEY;
3406     pkt->pkt.secret_key = sk_protected;
3407     sk_protected = NULL;
3408
3409     rc = build_packet (fp, pkt);
3410     if (rc)
3411       {
3412         log_error("build packet failed: %s\n", g10_errstr(rc) );
3413         iobuf_cancel (fp);
3414       }
3415     else
3416       {
3417         byte array[MAX_FINGERPRINT_LEN];
3418         char *fprbuf, *p;
3419        
3420         iobuf_close (fp);
3421         iobuf_ioctl (NULL, 2, 0, (char*)fname);
3422         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3423
3424         fingerprint_from_sk (sk, array, &n);
3425         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
3426         for (i=0; i < n ; i++, p += 2)
3427           sprintf (p, "%02X", array[i]);
3428         *p++ = ' ';
3429         *p = 0;
3430
3431         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
3432                                       fprbuf,
3433                                       fname, strlen (fname),
3434                                       0);
3435         xfree (fprbuf);
3436       }
3437     free_packet (pkt);
3438     xfree (pkt);
3439     xfree (fname);
3440     if (rc)
3441       {
3442         free_secret_key (sk_unprotected);
3443         return rc;
3444       }
3445   }
3446
3447   /* Create the public key from the secret key. */
3448   pk = xcalloc (1, sizeof *pk );
3449   pk->timestamp = sk->timestamp;
3450   pk->version = sk->version;
3451   if (expireval)
3452       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3453   pk->pubkey_algo = sk->pubkey_algo;
3454   n = pubkey_get_npkey (sk->pubkey_algo);
3455   for (i=0; i < n; i++)
3456     pk->pkey[i] = mpi_copy (sk->skey[i]);
3457
3458   /* Build packets and add them to the node lists.  */
3459   pkt = xcalloc (1,sizeof *pkt);
3460   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3461   pkt->pkt.public_key = pk;
3462   add_kbnode(pub_root, new_kbnode( pkt ));
3463
3464   pkt = xcalloc (1,sizeof *pkt);
3465   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3466   pkt->pkt.secret_key = sk;
3467   add_kbnode(sec_root, new_kbnode( pkt ));
3468
3469   return 0;
3470 #else
3471   return -1;
3472 #endif /*!ENABLE_CARD_SUPPORT*/
3473 }
3474
3475
3476 #ifdef ENABLE_CARD_SUPPORT
3477 int
3478 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3479 {
3480   int rc;
3481   unsigned char *rsa_n = NULL;
3482   unsigned char *rsa_e = NULL;
3483   unsigned char *rsa_p = NULL;
3484   unsigned char *rsa_q = NULL;
3485   unsigned int rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3486   unsigned char *sexp = NULL;
3487   unsigned char *p;
3488   char numbuf[55], numbuf2[50];
3489
3490   assert (is_RSA (sk->pubkey_algo));
3491   assert (!sk->is_protected);
3492
3493   /* Copy the parameters into straight buffers. */
3494   rsa_n = mpi_get_secure_buffer (sk->skey[0], &rsa_n_len, NULL);
3495   rsa_e = mpi_get_secure_buffer (sk->skey[1], &rsa_e_len, NULL);
3496   rsa_p = mpi_get_secure_buffer (sk->skey[3], &rsa_p_len, NULL);
3497   rsa_q = mpi_get_secure_buffer (sk->skey[4], &rsa_q_len, NULL);
3498   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
3499     {
3500       rc = G10ERR_INV_ARG;
3501       goto leave;
3502     }
3503
3504   /* Put the key into an S-expression. */
3505   sexp = p = xmalloc_secure (30
3506                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
3507                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
3508
3509   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
3510   sprintf (numbuf, "%u:", rsa_n_len);
3511   p = stpcpy (p, numbuf);
3512   memcpy (p, rsa_n, rsa_n_len);
3513   p += rsa_n_len;
3514
3515   sprintf (numbuf, ")(1:e%u:", rsa_e_len);
3516   p = stpcpy (p, numbuf);
3517   memcpy (p, rsa_e, rsa_e_len);
3518   p += rsa_e_len;
3519
3520   sprintf (numbuf, ")(1:p%u:", rsa_p_len);
3521   p = stpcpy (p, numbuf);
3522   memcpy (p, rsa_p, rsa_p_len);
3523   p += rsa_p_len;
3524
3525   sprintf (numbuf, ")(1:q%u:", rsa_q_len);
3526   p = stpcpy (p, numbuf);
3527   memcpy (p, rsa_q, rsa_q_len);
3528   p += rsa_q_len;
3529
3530   p = stpcpy (p,"))(10:created-at");
3531   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
3532   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
3533   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
3534
3535   rc = agent_scd_writekey (keyno, sexp, p - sexp);
3536
3537  leave:
3538   xfree (sexp);
3539   xfree (rsa_n);
3540   xfree (rsa_e);
3541   xfree (rsa_p);
3542   xfree (rsa_q);
3543   return rc;
3544 }
3545 #endif /*ENABLE_CARD_SUPPORT*/