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