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