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