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