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