* misc.c (is_secured_filename): New.
[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     char *answer;
1406     unsigned nbits;
1407
1408     if (algo != PUBKEY_ALGO_DSA && algo != PUBKEY_ALGO_RSA) {
1409         tty_printf (_("About to generate a new %s keypair.\n"
1410                       "              minimum keysize is  768 bits\n"
1411                       "              default keysize is 1024 bits\n"
1412                       "    highest suggested keysize is 2048 bits\n"),
1413                     pubkey_algo_to_string(algo) );
1414     }
1415
1416     for(;;) {
1417         answer = cpr_get("keygen.size",
1418                           _("What keysize do you want? (1024) "));
1419         cpr_kill_prompt();
1420         nbits = *answer? atoi(answer): 1024;
1421         m_free(answer);
1422         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
1423             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
1424         else if( algo == PUBKEY_ALGO_RSA && nbits < 1024 )
1425             tty_printf(_("keysize too small;"
1426                          " 1024 is smallest value allowed for RSA.\n"));
1427         else if( nbits < 768 )
1428             tty_printf(_("keysize too small;"
1429                          " 768 is smallest value allowed.\n"));
1430         else if( nbits > 4096 ) {
1431             /* It is ridiculous and an annoyance to use larger key sizes!
1432              * GnuPG can handle much larger sizes; but it takes an eternity
1433              * to create such a key (but less than the time the Sirius
1434              * Computer Corporation needs to process one of the usual
1435              * complaints) and {de,en}cryption although needs some time.
1436              * So, before you complain about this limitation, I suggest that
1437              * you start a discussion with Marvin about this theme and then
1438              * do whatever you want. */
1439             tty_printf(_("keysize too large; %d is largest value allowed.\n"),
1440                                                                          4096);
1441         }
1442         else if( nbits > 2048 && !cpr_enabled() ) {
1443             tty_printf(
1444                 _("Keysizes larger than 2048 are not suggested because\n"
1445                   "computations take REALLY long!\n"));
1446             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
1447                         "Are you sure that you want this keysize? (y/N) ")) )
1448               {
1449                 tty_printf(_("Okay, but keep in mind that your monitor "
1450                              "and keyboard radiation is also very vulnerable "
1451                              "to attacks!\n"));
1452                 break;
1453               }
1454         }
1455         else
1456             break;
1457     }
1458     tty_printf(_("Requested keysize is %u bits\n"), nbits );
1459     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
1460         nbits = ((nbits + 63) / 64) * 64;
1461         tty_printf(_("rounded up to %u bits\n"), nbits );
1462     }
1463     else if( (nbits % 32) ) {
1464         nbits = ((nbits + 31) / 32) * 32;
1465         tty_printf(_("rounded up to %u bits\n"), nbits );
1466     }
1467     return nbits;
1468 }
1469
1470
1471 /****************
1472  * Parse an expire string and return it's value in days.
1473  * Returns -1 on error.
1474  */
1475 static int
1476 parse_expire_string( const char *string )
1477 {
1478     int mult;
1479     u32 abs_date=0;
1480     u32 curtime = make_timestamp();
1481     int valid_days;
1482
1483     if( !*string )
1484         valid_days = 0;
1485     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
1486         /* This calculation is not perfectly okay because we
1487          * are later going to simply multiply by 86400 and don't
1488          * correct for leapseconds.  A solution would be to change
1489          * the whole implemenation to work with dates and not intervals
1490          * which are required for v3 keys.
1491          */
1492         valid_days = abs_date/86400-curtime/86400+1;
1493     }
1494     else if( (mult=check_valid_days(string)) ) {
1495         valid_days = atoi(string) * mult;
1496         if( valid_days < 0 || valid_days > 39447 )
1497             valid_days = 0;
1498     }
1499     else {
1500         valid_days = -1;
1501     }
1502     return valid_days;
1503 }
1504
1505 /* object == 0 for a key, and 1 for a sig */
1506 u32
1507 ask_expire_interval(int object)
1508 {
1509     char *answer;
1510     int valid_days=0;
1511     u32 interval = 0;
1512
1513     switch(object)
1514       {
1515       case 0:
1516         tty_printf(_("Please specify how long the key should be valid.\n"
1517                      "         0 = key does not expire\n"
1518                      "      <n>  = key expires in n days\n"
1519                      "      <n>w = key expires in n weeks\n"
1520                      "      <n>m = key expires in n months\n"
1521                      "      <n>y = key expires in n years\n"));
1522         break;
1523
1524       case 1:
1525         tty_printf(_("Please specify how long the signature should be valid.\n"
1526                      "         0 = signature does not expire\n"
1527                      "      <n>  = signature expires in n days\n"
1528                      "      <n>w = signature expires in n weeks\n"
1529                      "      <n>m = signature expires in n months\n"
1530                      "      <n>y = signature expires in n years\n"));
1531         break;
1532
1533       default:
1534         BUG();
1535       }
1536
1537     /* Note: The elgamal subkey for DSA has no expiration date because
1538      * it must be signed with the DSA key and this one has the expiration
1539      * date */
1540
1541     answer = NULL;
1542     for(;;) {
1543         u32 curtime=make_timestamp();
1544
1545         m_free(answer);
1546         if(object==0)
1547           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1548         else
1549           answer = cpr_get("siggen.valid",_("Signature is valid for? (0) "));
1550         cpr_kill_prompt();
1551         trim_spaces(answer);
1552         valid_days = parse_expire_string( answer );
1553         if( valid_days < 0 ) {
1554             tty_printf(_("invalid value\n"));
1555             continue;
1556         }
1557
1558         if( !valid_days ) {
1559             tty_printf(_("%s does not expire at all\n"),
1560                        object==0?"Key":"Signature");
1561             interval = 0;
1562         }
1563         else {
1564             interval = valid_days * 86400L;
1565             /* print the date when the key expires */
1566             tty_printf(_("%s expires at %s\n"),
1567                         object==0?"Key":"Signature",
1568                         asctimestamp((ulong)(curtime + interval) ) );
1569             /* FIXME: This check yields warning on alhas:
1570                write a configure check and to this check here only for 32 bit machines */
1571             if( (time_t)((ulong)(curtime+interval)) < 0 )
1572                 tty_printf(_("Your system can't display dates beyond 2038.\n"
1573                     "However, it will be correctly handled up to 2106.\n"));
1574         }
1575
1576         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1577                                             _("Is this correct? (y/N) ")) )
1578             break;
1579     }
1580     m_free(answer);
1581     return interval;
1582 }
1583
1584 u32
1585 ask_expiredate()
1586 {
1587     u32 x = ask_expire_interval(0);
1588     return x? make_timestamp() + x : 0;
1589 }
1590
1591 static int
1592 has_invalid_email_chars( const char *s )
1593 {
1594     int at_seen=0;
1595     static char valid_chars[] = "01234567890_-."
1596                                 "abcdefghijklmnopqrstuvwxyz"
1597                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1598
1599     for( ; *s; s++ ) {
1600         if( *s & 0x80 )
1601             return 1;
1602         if( *s == '@' )
1603             at_seen=1;
1604         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1605             return 1;
1606         else if( at_seen && !strchr( valid_chars, *s ) )
1607             return 1;
1608     }
1609     return 0;
1610 }
1611
1612
1613 static char *
1614 ask_user_id( int mode )
1615 {
1616     char *answer;
1617     char *aname, *acomment, *amail, *uid;
1618
1619     if( !mode )
1620         tty_printf( _("\n"
1621 "You need a user ID to identify your key; the software constructs the user ID\n"
1622 "from the Real Name, Comment and Email Address in this form:\n"
1623 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1624     uid = aname = acomment = amail = NULL;
1625     for(;;) {
1626         char *p;
1627         int fail=0;
1628
1629         if( !aname ) {
1630             for(;;) {
1631                 m_free(aname);
1632                 aname = cpr_get("keygen.name",_("Real name: "));
1633                 trim_spaces(aname);
1634                 cpr_kill_prompt();
1635
1636                 if( opt.allow_freeform_uid )
1637                     break;
1638
1639                 if( strpbrk( aname, "<>" ) )
1640                     tty_printf(_("Invalid character in name\n"));
1641                 else if( digitp(aname) )
1642                     tty_printf(_("Name may not start with a digit\n"));
1643                 else if( strlen(aname) < 5 )
1644                     tty_printf(_("Name must be at least 5 characters long\n"));
1645                 else
1646                     break;
1647             }
1648         }
1649         if( !amail ) {
1650             for(;;) {
1651                 m_free(amail);
1652                 amail = cpr_get("keygen.email",_("Email address: "));
1653                 trim_spaces(amail);
1654                 cpr_kill_prompt();
1655                 if( !*amail || opt.allow_freeform_uid )
1656                     break;   /* no email address is okay */
1657                 else if( has_invalid_email_chars(amail)
1658                          || string_count_chr(amail,'@') != 1
1659                          || *amail == '@'
1660                          || amail[strlen(amail)-1] == '@'
1661                          || amail[strlen(amail)-1] == '.'
1662                          || strstr(amail, "..") )
1663                     tty_printf(_("Not a valid email address\n"));
1664                 else
1665                     break;
1666             }
1667         }
1668         if( !acomment ) {
1669             for(;;) {
1670                 m_free(acomment);
1671                 acomment = cpr_get("keygen.comment",_("Comment: "));
1672                 trim_spaces(acomment);
1673                 cpr_kill_prompt();
1674                 if( !*acomment )
1675                     break;   /* no comment is okay */
1676                 else if( strpbrk( acomment, "()" ) )
1677                     tty_printf(_("Invalid character in comment\n"));
1678                 else
1679                     break;
1680             }
1681         }
1682
1683
1684         m_free(uid);
1685         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1686         p = stpcpy(p, aname );
1687         if( *acomment )
1688             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1689         if( *amail )
1690             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1691
1692         /* append a warning if we do not have dev/random
1693          * or it is switched into  quick testmode */
1694         if( quick_random_gen(-1) )
1695             strcpy(p, " (INSECURE!)" );
1696
1697         /* print a note in case that UTF8 mapping has to be done */
1698         for(p=uid; *p; p++ ) {
1699             if( *p & 0x80 ) {
1700                 tty_printf(_("You are using the `%s' character set.\n"),
1701                            get_native_charset() );
1702                 break;
1703             }
1704         }
1705
1706         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1707         /* fixme: add a warning if this user-id already exists */
1708         if( !*amail && !opt.allow_freeform_uid
1709             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1710             fail = 1;
1711             tty_printf(_("Please don't put the email address "
1712                           "into the real name or the comment\n") );
1713         }
1714
1715         for(;;) {
1716             const char *ansstr = _("NnCcEeOoQq");
1717
1718             if( strlen(ansstr) != 10 )
1719                 BUG();
1720             if( cpr_enabled() ) {
1721                 answer = m_strdup(ansstr+6);
1722                 answer[1] = 0;
1723             }
1724             else {
1725                 answer = cpr_get("keygen.userid.cmd", fail?
1726                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1727                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1728                 cpr_kill_prompt();
1729             }
1730             if( strlen(answer) > 1 )
1731                 ;
1732             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1733                 m_free(aname); aname = NULL;
1734                 break;
1735             }
1736             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1737                 m_free(acomment); acomment = NULL;
1738                 break;
1739             }
1740             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1741                 m_free(amail); amail = NULL;
1742                 break;
1743             }
1744             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1745                 if( fail ) {
1746                     tty_printf(_("Please correct the error first\n"));
1747                 }
1748                 else {
1749                     m_free(aname); aname = NULL;
1750                     m_free(acomment); acomment = NULL;
1751                     m_free(amail); amail = NULL;
1752                     break;
1753                 }
1754             }
1755             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1756                 m_free(aname); aname = NULL;
1757                 m_free(acomment); acomment = NULL;
1758                 m_free(amail); amail = NULL;
1759                 m_free(uid); uid = NULL;
1760                 break;
1761             }
1762             m_free(answer);
1763         }
1764         m_free(answer);
1765         if( !amail && !acomment && !amail )
1766             break;
1767         m_free(uid); uid = NULL;
1768     }
1769     if( uid ) {
1770         char *p = native_to_utf8( uid );
1771         m_free( uid );
1772         uid = p;
1773     }
1774     return uid;
1775 }
1776
1777
1778 /* FIXME: We need a way to cancel this prompt. */
1779 static DEK *
1780 do_ask_passphrase( STRING2KEY **ret_s2k )
1781 {
1782     DEK *dek = NULL;
1783     STRING2KEY *s2k;
1784     const char *errtext = NULL;
1785
1786     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1787
1788     s2k = m_alloc_secure( sizeof *s2k );
1789     for(;;) {
1790         s2k->mode = opt.s2k_mode;
1791         s2k->hash_algo = S2K_DIGEST_ALGO;
1792         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1793                                  errtext, NULL);
1794         if( !dek ) {
1795             errtext = N_("passphrase not correctly repeated; try again");
1796             tty_printf(_("%s.\n"), _(errtext));
1797         }
1798         else if( !dek->keylen ) {
1799             m_free(dek); dek = NULL;
1800             m_free(s2k); s2k = NULL;
1801             tty_printf(_(
1802             "You don't want a passphrase - this is probably a *bad* idea!\n"
1803             "I will do it anyway.  You can change your passphrase at any time,\n"
1804             "using this program with the option \"--edit-key\".\n\n"));
1805             break;
1806         }
1807         else
1808             break; /* okay */
1809     }
1810     *ret_s2k = s2k;
1811     return dek;
1812 }
1813
1814
1815 static int
1816 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1817            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
1818            int is_subkey )
1819 {
1820   int rc=0;
1821
1822   if( !opt.batch )
1823     tty_printf(_(
1824 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1825 "some other action (type on the keyboard, move the mouse, utilize the\n"
1826 "disks) during the prime generation; this gives the random number\n"
1827 "generator a better chance to gain enough entropy.\n") );
1828
1829   if( algo == PUBKEY_ALGO_ELGAMAL_E )
1830     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1831                  is_subkey);
1832   else if( algo == PUBKEY_ALGO_DSA )
1833     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1834                  is_subkey);
1835   else if( algo == PUBKEY_ALGO_RSA )
1836     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1837                  is_subkey);
1838   else
1839     BUG();
1840
1841 #ifdef ENABLE_COMMENT_PACKETS
1842   if( !rc ) {
1843     add_kbnode( pub_root,
1844                 make_comment_node("#created by GNUPG v" VERSION " ("
1845                                   PRINTABLE_OS_NAME ")"));
1846     add_kbnode( sec_root,
1847                 make_comment_node("#created by GNUPG v" VERSION " ("
1848                                   PRINTABLE_OS_NAME ")"));
1849   }
1850 #endif
1851   return rc;
1852 }
1853
1854
1855 /****************
1856  * Generate a new user id packet, or return NULL if canceled
1857  */
1858 PKT_user_id *
1859 generate_user_id()
1860 {
1861     PKT_user_id *uid;
1862     char *p;
1863     size_t n;
1864
1865     p = ask_user_id( 1 );
1866     if( !p )
1867         return NULL;
1868     n = strlen(p);
1869     uid = m_alloc_clear( sizeof *uid + n - 1 );
1870     uid->len = n;
1871     strcpy(uid->name, p);
1872     uid->ref = 1;
1873     return uid;
1874 }
1875
1876
1877 static void
1878 release_parameter_list( struct para_data_s *r )
1879 {
1880     struct para_data_s *r2;
1881
1882     for( ; r ; r = r2 ) {
1883         r2 = r->next;
1884         if( r->key == pPASSPHRASE_DEK )
1885             m_free( r->u.dek );
1886         else if( r->key == pPASSPHRASE_S2K )
1887             m_free( r->u.s2k );
1888
1889         m_free(r);
1890     }
1891 }
1892
1893 static struct para_data_s *
1894 get_parameter( struct para_data_s *para, enum para_name key )
1895 {
1896     struct para_data_s *r;
1897
1898     for( r = para; r && r->key != key; r = r->next )
1899         ;
1900     return r;
1901 }
1902
1903 static const char *
1904 get_parameter_value( struct para_data_s *para, enum para_name key )
1905 {
1906     struct para_data_s *r = get_parameter( para, key );
1907     return (r && *r->u.value)? r->u.value : NULL;
1908 }
1909
1910 static int
1911 get_parameter_algo( struct para_data_s *para, enum para_name key )
1912 {
1913     int i;
1914     struct para_data_s *r = get_parameter( para, key );
1915     if( !r )
1916         return -1;
1917     if( digitp( r->u.value ) )
1918         i = atoi( r->u.value );
1919     else
1920         i = string_to_pubkey_algo( r->u.value );
1921     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1922       i = 0; /* we don't want to allow generation of these algorithms */
1923     return i;
1924 }
1925
1926 /* 
1927  * parse the usage parameter and set the keyflags.  Return true on error.
1928  */
1929 static int
1930 parse_parameter_usage (const char *fname,
1931                        struct para_data_s *para, enum para_name key)
1932 {
1933     struct para_data_s *r = get_parameter( para, key );
1934     char *p, *pn;
1935     unsigned int use;
1936
1937     if( !r )
1938         return 0; /* none (this is an optional parameter)*/
1939     
1940     use = 0;
1941     pn = r->u.value;
1942     while ( (p = strsep (&pn, " \t,")) ) {
1943         if ( !*p)
1944             ;
1945         else if ( !ascii_strcasecmp (p, "sign") )
1946             use |= PUBKEY_USAGE_SIG;
1947         else if ( !ascii_strcasecmp (p, "encrypt") )
1948             use |= PUBKEY_USAGE_ENC;
1949         else if ( !ascii_strcasecmp (p, "auth") )
1950             use |= PUBKEY_USAGE_AUTH;
1951         else {
1952             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1953             return -1; /* error */
1954         }
1955     }
1956     r->u.usage = use;
1957     return 0;
1958 }
1959
1960 static int
1961 parse_revocation_key (const char *fname,
1962                       struct para_data_s *para, enum para_name key)
1963 {
1964   struct para_data_s *r = get_parameter( para, key );
1965   struct revocation_key revkey;
1966   char *pn;
1967   int i;
1968
1969   if( !r )
1970     return 0; /* none (this is an optional parameter) */
1971
1972   pn = r->u.value;
1973
1974   revkey.class=0x80;
1975   revkey.algid=atoi(pn);
1976   if(!revkey.algid)
1977     goto fail;
1978
1979   /* Skip to the fpr */
1980   while(*pn && *pn!=':')
1981     pn++;
1982
1983   if(*pn!=':')
1984     goto fail;
1985
1986   pn++;
1987
1988   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1989     {
1990       int c=hextobyte(pn);
1991       if(c==-1)
1992         goto fail;
1993
1994       revkey.fpr[i]=c;
1995     }
1996
1997   /* skip to the tag */
1998   while(*pn && *pn!='s' && *pn!='S')
1999     pn++;
2000
2001   if(ascii_strcasecmp(pn,"sensitive")==0)
2002     revkey.class|=0x40;
2003
2004   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2005
2006   return 0;
2007
2008   fail:
2009   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2010   return -1; /* error */
2011 }
2012
2013
2014 static u32
2015 get_parameter_u32( struct para_data_s *para, enum para_name key )
2016 {
2017     struct para_data_s *r = get_parameter( para, key );
2018
2019     if( !r )
2020         return 0;
2021     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2022         return r->u.expire;
2023     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2024         return r->u.usage;
2025
2026     return (unsigned int)strtoul( r->u.value, NULL, 10 );
2027 }
2028
2029 static unsigned int
2030 get_parameter_uint( struct para_data_s *para, enum para_name key )
2031 {
2032     return get_parameter_u32( para, key );
2033 }
2034
2035 static DEK *
2036 get_parameter_dek( struct para_data_s *para, enum para_name key )
2037 {
2038     struct para_data_s *r = get_parameter( para, key );
2039     return r? r->u.dek : NULL;
2040 }
2041
2042 static STRING2KEY *
2043 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2044 {
2045     struct para_data_s *r = get_parameter( para, key );
2046     return r? r->u.s2k : NULL;
2047 }
2048
2049 static struct revocation_key *
2050 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2051 {
2052     struct para_data_s *r = get_parameter( para, key );
2053     return r? &r->u.revkey : NULL;
2054 }
2055
2056 static int
2057 proc_parameter_file( struct para_data_s *para, const char *fname,
2058                      struct output_control_s *outctrl, int card )
2059 {
2060     struct para_data_s *r;
2061     const char *s1, *s2, *s3;
2062     size_t n;
2063     char *p;
2064     int i;
2065
2066     /* Check that we have all required parameters. */
2067     assert( get_parameter( para, pKEYTYPE ) );
2068     i = get_parameter_algo( para, pKEYTYPE );
2069     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
2070         r = get_parameter( para, pKEYTYPE );
2071         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2072         return -1;
2073     }
2074
2075     if (parse_parameter_usage (fname, para, pKEYUSAGE))
2076         return -1;
2077
2078     i = get_parameter_algo( para, pSUBKEYTYPE );
2079     if( i > 0 && check_pubkey_algo( i ) ) {
2080         r = get_parameter( para, pSUBKEYTYPE );
2081         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2082         return -1;
2083     }
2084     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
2085         return -1;
2086
2087
2088     if( !get_parameter_value( para, pUSERID ) ) {
2089         /* create the formatted user ID */
2090         s1 = get_parameter_value( para, pNAMEREAL );
2091         s2 = get_parameter_value( para, pNAMECOMMENT );
2092         s3 = get_parameter_value( para, pNAMEEMAIL );
2093         if( s1 || s2 || s3 ) {
2094             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2095             r = m_alloc_clear( sizeof *r + n + 20 );
2096             r->key = pUSERID;
2097             p = r->u.value;
2098             if( s1 )
2099                 p = stpcpy(p, s1 );
2100             if( s2 )
2101                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2102             if( s3 )
2103                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2104             r->next = para;
2105             para = r;
2106         }
2107     }
2108
2109     /* Set preferences, if any. */
2110     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2111
2112     /* Set revoker, if any. */
2113     if (parse_revocation_key (fname, para, pREVOKER))
2114       return -1;
2115
2116     /* make DEK and S2K from the Passphrase */
2117     r = get_parameter( para, pPASSPHRASE );
2118     if( r && *r->u.value ) {
2119         /* we have a plain text passphrase - create a DEK from it.
2120          * It is a little bit ridiculous to keep it ih secure memory
2121          * but becuase we do this alwasy, why not here */
2122         STRING2KEY *s2k;
2123         DEK *dek;
2124
2125         s2k = m_alloc_secure( sizeof *s2k );
2126         s2k->mode = opt.s2k_mode;
2127         s2k->hash_algo = S2K_DIGEST_ALGO;
2128         set_next_passphrase( r->u.value );
2129         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2130                                  NULL, NULL);
2131         set_next_passphrase( NULL );
2132         assert( dek );
2133         memset( r->u.value, 0, strlen(r->u.value) );
2134
2135         r = m_alloc_clear( sizeof *r );
2136         r->key = pPASSPHRASE_S2K;
2137         r->u.s2k = s2k;
2138         r->next = para;
2139         para = r;
2140         r = m_alloc_clear( sizeof *r );
2141         r->key = pPASSPHRASE_DEK;
2142         r->u.dek = dek;
2143         r->next = para;
2144         para = r;
2145     }
2146
2147     /* make KEYEXPIRE from Expire-Date */
2148     r = get_parameter( para, pEXPIREDATE );
2149     if( r && *r->u.value ) {
2150         i = parse_expire_string( r->u.value );
2151         if( i < 0 ) {
2152             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2153             return -1;
2154         }
2155         r->u.expire = i * 86400L;
2156         r->key = pKEYEXPIRE;  /* change hat entry */
2157         /* also set it for the subkey */
2158         r = m_alloc_clear( sizeof *r + 20 );
2159         r->key = pSUBKEYEXPIRE;
2160         r->u.expire = i * 86400L;
2161         r->next = para;
2162         para = r;
2163     }
2164
2165     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2166         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2167         return -1;
2168     }
2169
2170     do_generate_keypair( para, outctrl, card );
2171     return 0;
2172 }
2173
2174
2175 /****************
2176  * Kludge to allow non interactive key generation controlled
2177  * by a parameter file.
2178  * Note, that string parameters are expected to be in UTF-8
2179  */
2180 static void
2181 read_parameter_file( const char *fname )
2182 {
2183     static struct { const char *name;
2184                     enum para_name key;
2185     } keywords[] = {
2186         { "Key-Type",       pKEYTYPE},
2187         { "Key-Length",     pKEYLENGTH },
2188         { "Key-Usage",      pKEYUSAGE },
2189         { "Subkey-Type",    pSUBKEYTYPE },
2190         { "Subkey-Length",  pSUBKEYLENGTH },
2191         { "Subkey-Usage",   pSUBKEYUSAGE },
2192         { "Name-Real",      pNAMEREAL },
2193         { "Name-Email",     pNAMEEMAIL },
2194         { "Name-Comment",   pNAMECOMMENT },
2195         { "Expire-Date",    pEXPIREDATE },
2196         { "Passphrase",     pPASSPHRASE },
2197         { "Preferences",    pPREFERENCES },
2198         { "Revoker",        pREVOKER },
2199         { "Handle",         pHANDLE },
2200         { NULL, 0 }
2201     };
2202     IOBUF fp;
2203     unsigned char *line;
2204     unsigned int maxlen, nline;
2205     char *p;
2206     int lnr;
2207     const char *err = NULL;
2208     struct para_data_s *para, *r;
2209     int i;
2210     struct output_control_s outctrl;
2211
2212     memset( &outctrl, 0, sizeof( outctrl ) );
2213
2214     if( !fname || !*fname)
2215       fname = "-";
2216
2217     fp = iobuf_open (fname);
2218     if (fp && is_secured_file (iobuf_get_fd (fp)))
2219       {
2220         iobuf_close (fp);
2221         fp = NULL;
2222         errno = EPERM;
2223       }
2224     if (!fp) {
2225       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2226       return;
2227     }
2228     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2229
2230     lnr = 0;
2231     err = NULL;
2232     para = NULL;
2233     maxlen = 1024;
2234     line = NULL;
2235     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2236         char *keyword, *value;
2237
2238         lnr++;
2239         if( !maxlen ) {
2240             err = "line too long";
2241             break;
2242         }
2243         for( p = line; isspace(*(byte*)p); p++ )
2244             ;
2245         if( !*p || *p == '#' )
2246             continue;
2247         keyword = p;
2248         if( *keyword == '%' ) {
2249             for( ; !isspace(*(byte*)p); p++ )
2250                 ;
2251             if( *p )
2252                 *p++ = 0;
2253             for( ; isspace(*(byte*)p); p++ )
2254                 ;
2255             value = p;
2256             trim_trailing_ws( value, strlen(value) );
2257             if( !ascii_strcasecmp( keyword, "%echo" ) )
2258                 log_info("%s\n", value );
2259             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2260                 outctrl.dryrun = 1;
2261             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2262                 outctrl.lnr = lnr;
2263                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2264                   print_status_key_not_created 
2265                     (get_parameter_value (para, pHANDLE));
2266                 release_parameter_list( para );
2267                 para = NULL;
2268             }
2269             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2270                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2271                     ; /* still the same file - ignore it */
2272                 else {
2273                     m_free( outctrl.pub.newfname );
2274                     outctrl.pub.newfname = m_strdup( value );
2275                     outctrl.use_files = 1;
2276                 }
2277             }
2278             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2279                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2280                     ; /* still the same file - ignore it */
2281                 else {
2282                    m_free( outctrl.sec.newfname );
2283                    outctrl.sec.newfname = m_strdup( value );
2284                    outctrl.use_files = 1;
2285                 }
2286             }
2287             else
2288                 log_info("skipping control `%s' (%s)\n", keyword, value );
2289
2290
2291             continue;
2292         }
2293
2294
2295         if( !(p = strchr( p, ':' )) || p == keyword ) {
2296             err = "missing colon";
2297             break;
2298         }
2299         if( *p )
2300             *p++ = 0;
2301         for( ; isspace(*(byte*)p); p++ )
2302             ;
2303         if( !*p ) {
2304             err = "missing argument";
2305             break;
2306         }
2307         value = p;
2308         trim_trailing_ws( value, strlen(value) );
2309
2310         for(i=0; keywords[i].name; i++ ) {
2311             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2312                 break;
2313         }
2314         if( !keywords[i].name ) {
2315             err = "unknown keyword";
2316             break;
2317         }
2318         if( keywords[i].key != pKEYTYPE && !para ) {
2319             err = "parameter block does not start with \"Key-Type\"";
2320             break;
2321         }
2322
2323         if( keywords[i].key == pKEYTYPE && para ) {
2324             outctrl.lnr = lnr;
2325             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2326               print_status_key_not_created
2327                 (get_parameter_value (para, pHANDLE));
2328             release_parameter_list( para );
2329             para = NULL;
2330         }
2331         else {
2332             for( r = para; r; r = r->next ) {
2333                 if( r->key == keywords[i].key )
2334                     break;
2335             }
2336             if( r ) {
2337                 err = "duplicate keyword";
2338                 break;
2339             }
2340         }
2341         r = m_alloc_clear( sizeof *r + strlen( value ) );
2342         r->lnr = lnr;
2343         r->key = keywords[i].key;
2344         strcpy( r->u.value, value );
2345         r->next = para;
2346         para = r;
2347     }
2348     if( err )
2349         log_error("%s:%d: %s\n", fname, lnr, err );
2350     else if( iobuf_error (fp) ) {
2351         log_error("%s:%d: read error\n", fname, lnr);
2352     }
2353     else if( para ) {
2354         outctrl.lnr = lnr;
2355         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2356           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2357     }
2358
2359     if( outctrl.use_files ) { /* close open streams */
2360         iobuf_close( outctrl.pub.stream );
2361         iobuf_close( outctrl.sec.stream );
2362
2363         /* Must invalidate that ugly cache to actually close it.  */
2364         if (outctrl.pub.fname)
2365           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2366         if (outctrl.sec.fname)
2367           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2368
2369         m_free( outctrl.pub.fname );
2370         m_free( outctrl.pub.newfname );
2371         m_free( outctrl.sec.fname );
2372         m_free( outctrl.sec.newfname );
2373     }
2374
2375     release_parameter_list( para );
2376     iobuf_close (fp);
2377 }
2378
2379
2380 /*
2381  * Generate a keypair (fname is only used in batch mode) If
2382  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2383  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2384  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2385  * generate in software, imported to the card and a backup file
2386  * written to directory given by this argument .
2387  */
2388 void
2389 generate_keypair (const char *fname, const char *card_serialno, 
2390                   const char *backup_encryption_dir)
2391 {
2392   unsigned int nbits;
2393   char *uid = NULL;
2394   DEK *dek;
2395   STRING2KEY *s2k;
2396   int algo;
2397   unsigned int use;
2398   int both = 0;
2399   u32 expire;
2400   struct para_data_s *para = NULL;
2401   struct para_data_s *r;
2402   struct output_control_s outctrl;
2403   
2404   memset( &outctrl, 0, sizeof( outctrl ) );
2405   
2406   if (opt.batch && card_serialno)
2407     {
2408       /* We don't yet support unattended key generation. */
2409       log_error (_("sorry, can't do this in batch mode\n"));
2410       return;
2411     }
2412   
2413   if (opt.batch)
2414     {
2415       read_parameter_file( fname );
2416       return;
2417     }
2418
2419   if (card_serialno)
2420     {
2421 #ifdef ENABLE_CARD_SUPPORT
2422       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2423       r->key = pSERIALNO;
2424       strcpy( r->u.value, card_serialno);
2425       r->next = para;
2426       para = r;
2427        
2428       algo = PUBKEY_ALGO_RSA;
2429        
2430       r = xcalloc (1, sizeof *r + 20 );
2431       r->key = pKEYTYPE;
2432       sprintf( r->u.value, "%d", algo );
2433       r->next = para;
2434       para = r;
2435       r = xcalloc (1, sizeof *r + 20 );
2436       r->key = pKEYUSAGE;
2437       strcpy (r->u.value, "sign");
2438       r->next = para;
2439       para = r;
2440        
2441       r = xcalloc (1, sizeof *r + 20 );
2442       r->key = pSUBKEYTYPE;
2443       sprintf( r->u.value, "%d", algo );
2444       r->next = para;
2445       para = r;
2446       r = xcalloc (1, sizeof *r + 20 );
2447       r->key = pSUBKEYUSAGE;
2448       strcpy (r->u.value, "encrypt");
2449       r->next = para;
2450       para = r;
2451        
2452       r = xcalloc (1, sizeof *r + 20 );
2453       r->key = pAUTHKEYTYPE;
2454       sprintf( r->u.value, "%d", algo );
2455       r->next = para;
2456       para = r;
2457
2458       if (backup_encryption_dir)
2459         {
2460           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2461           r->key = pBACKUPENCDIR;
2462           strcpy (r->u.value, backup_encryption_dir);
2463           r->next = para;
2464           para = r;
2465         }
2466 #endif /*ENABLE_CARD_SUPPORT*/
2467     }
2468   else
2469     {
2470       algo = ask_algo( 0, &use );
2471       if( !algo )
2472         { /* default: DSA with ElG subkey of the specified size */
2473           both = 1;
2474           r = m_alloc_clear( sizeof *r + 20 );
2475           r->key = pKEYTYPE;
2476           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2477           r->next = para;
2478           para = r;
2479           tty_printf(_("DSA keypair will have 1024 bits.\n"));
2480           r = m_alloc_clear( sizeof *r + 20 );
2481           r->key = pKEYLENGTH;
2482           strcpy( r->u.value, "1024" );
2483           r->next = para;
2484           para = r;
2485           r = m_alloc_clear( sizeof *r + 20 );
2486           r->key = pKEYUSAGE;
2487           strcpy( r->u.value, "sign" );
2488           r->next = para;
2489           para = r;
2490            
2491           algo = PUBKEY_ALGO_ELGAMAL_E;
2492           r = m_alloc_clear( sizeof *r + 20 );
2493           r->key = pSUBKEYTYPE;
2494           sprintf( r->u.value, "%d", algo );
2495           r->next = para;
2496           para = r;
2497           r = m_alloc_clear( sizeof *r + 20 );
2498           r->key = pSUBKEYUSAGE;
2499           strcpy( r->u.value, "encrypt" );
2500           r->next = para;
2501           para = r;
2502         }
2503       else 
2504         {
2505           r = m_alloc_clear( sizeof *r + 20 );
2506           r->key = pKEYTYPE;
2507           sprintf( r->u.value, "%d", algo );
2508           r->next = para;
2509           para = r;
2510            
2511           if (use)
2512             {
2513               r = m_alloc_clear( sizeof *r + 25 );
2514               r->key = pKEYUSAGE;
2515               sprintf( r->u.value, "%s%s%s",
2516                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2517                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
2518                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
2519               r->next = para;
2520               para = r;
2521             }
2522            
2523         }
2524        
2525       nbits = ask_keysize( algo );
2526       r = m_alloc_clear( sizeof *r + 20 );
2527       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2528       sprintf( r->u.value, "%u", nbits);
2529       r->next = para;
2530       para = r;
2531     }
2532    
2533   expire = ask_expire_interval(0);
2534   r = m_alloc_clear( sizeof *r + 20 );
2535   r->key = pKEYEXPIRE;
2536   r->u.expire = expire;
2537   r->next = para;
2538   para = r;
2539   r = m_alloc_clear( sizeof *r + 20 );
2540   r->key = pSUBKEYEXPIRE;
2541   r->u.expire = expire;
2542   r->next = para;
2543   para = r;
2544
2545   uid = ask_user_id(0);
2546   if( !uid ) 
2547     {
2548       log_error(_("Key generation canceled.\n"));
2549       release_parameter_list( para );
2550       return;
2551     }
2552   r = m_alloc_clear( sizeof *r + strlen(uid) );
2553   r->key = pUSERID;
2554   strcpy( r->u.value, uid );
2555   r->next = para;
2556   para = r;
2557     
2558   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2559   if( dek )
2560     {
2561       r = m_alloc_clear( sizeof *r );
2562       r->key = pPASSPHRASE_DEK;
2563       r->u.dek = dek;
2564       r->next = para;
2565       para = r;
2566       r = m_alloc_clear( sizeof *r );
2567       r->key = pPASSPHRASE_S2K;
2568       r->u.s2k = s2k;
2569       r->next = para;
2570       para = r;
2571     }
2572     
2573   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2574   release_parameter_list( para );
2575 }
2576
2577
2578 #ifdef ENABLE_CARD_SUPPORT
2579 /* Generate a raw key and return it as a secret key packet.  The
2580    function will ask for the passphrase and return a protected as well
2581    as an unprotected copy of a new secret key packet.  0 is returned
2582    on success and the caller must then free the returned values.  */
2583 static int
2584 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
2585                   PKT_secret_key **r_sk_unprotected,
2586                   PKT_secret_key **r_sk_protected)
2587 {
2588   int rc;
2589   DEK *dek = NULL;
2590   STRING2KEY *s2k = NULL;
2591   PKT_secret_key *sk = NULL;
2592   int i;
2593   size_t nskey, npkey;
2594
2595   npkey = pubkey_get_npkey (algo);
2596   nskey = pubkey_get_nskey (algo);
2597   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
2598
2599   if (nbits < 512)
2600     {
2601       nbits = 512;
2602       log_info (_("keysize invalid; using %u bits\n"), nbits );
2603     }
2604
2605   if ((nbits % 32)) 
2606     {
2607       nbits = ((nbits + 31) / 32) * 32;
2608       log_info(_("keysize rounded up to %u bits\n"), nbits );
2609     }
2610
2611   dek = do_ask_passphrase (&s2k);
2612
2613   sk = m_alloc_clear (sizeof *sk);
2614   sk->timestamp = created_at;
2615   sk->version = 4;
2616   sk->pubkey_algo = algo;
2617
2618   rc = pubkey_generate (algo, nbits, sk->skey, NULL);
2619   if (rc)
2620     {
2621       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
2622       goto leave;
2623     }
2624
2625   for (i=npkey; i < nskey; i++)
2626     sk->csum += checksum_mpi (sk->skey[i]);
2627
2628   if (r_sk_unprotected) 
2629     *r_sk_unprotected = copy_secret_key (NULL, sk);
2630
2631   if (dek)
2632     {
2633       sk->protect.algo = dek->algo;
2634       sk->protect.s2k = *s2k;
2635       rc = protect_secret_key (sk, dek);
2636       if (rc)
2637         {
2638           log_error ("protect_secret_key failed: %s\n", g10_errstr(rc));
2639           goto leave;
2640         }
2641     }
2642   if (r_sk_protected)
2643     {
2644       *r_sk_protected = sk;
2645       sk = NULL;
2646     }
2647
2648  leave:
2649   if (sk)
2650     free_secret_key (sk);
2651   m_free (dek);
2652   m_free (s2k);
2653   return rc;
2654 }
2655 #endif /* ENABLE_CARD_SUPPORT */
2656
2657
2658 static void
2659 do_generate_keypair( struct para_data_s *para,
2660                      struct output_control_s *outctrl, int card )
2661 {
2662     KBNODE pub_root = NULL;
2663     KBNODE sec_root = NULL;
2664     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2665     const char *s;
2666     struct revocation_key *revkey;
2667     int rc;
2668     int did_sub = 0;
2669
2670     if( outctrl->dryrun ) {
2671         log_info("dry-run mode - key generation skipped\n");
2672         return;
2673     }
2674
2675
2676     if( outctrl->use_files ) {
2677         if( outctrl->pub.newfname ) {
2678             iobuf_close(outctrl->pub.stream);
2679             outctrl->pub.stream = NULL;
2680             if (outctrl->pub.fname)
2681               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
2682             m_free( outctrl->pub.fname );
2683             outctrl->pub.fname =  outctrl->pub.newfname;
2684             outctrl->pub.newfname = NULL;
2685
2686             if (is_secured_filename (outctrl->pub.fname) ) {
2687                 outctrl->pub.stream = NULL;
2688                 errno = EPERM;
2689             }
2690             else
2691                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2692             if( !outctrl->pub.stream ) {
2693                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
2694                                                      strerror(errno) );
2695                 return;
2696             }
2697             if( opt.armor ) {
2698                 outctrl->pub.afx.what = 1;
2699                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2700                                                     &outctrl->pub.afx );
2701             }
2702         }
2703         if( outctrl->sec.newfname ) {
2704             mode_t oldmask;
2705
2706             iobuf_close(outctrl->sec.stream);
2707             outctrl->sec.stream = NULL;
2708             if (outctrl->sec.fname)
2709               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
2710             m_free( outctrl->sec.fname );
2711             outctrl->sec.fname =  outctrl->sec.newfname;
2712             outctrl->sec.newfname = NULL;
2713
2714             oldmask = umask (077);
2715             if (is_secured_filename (outctrl->sec.fname) ) {
2716                 outctrl->sec.stream = NULL;
2717                 errno = EPERM;
2718             }
2719             else
2720                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2721             umask (oldmask);
2722             if( !outctrl->sec.stream ) {
2723                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
2724                                                      strerror(errno) );
2725                 return;
2726             }
2727             if( opt.armor ) {
2728                 outctrl->sec.afx.what = 5;
2729                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2730                                                     &outctrl->sec.afx );
2731             }
2732         }
2733         assert( outctrl->pub.stream );
2734         assert( outctrl->sec.stream );
2735         if( opt.verbose ) {
2736             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2737             if (card)
2738               log_info (_("writing secret key stub to `%s'\n"),
2739                         outctrl->sec.fname);
2740             else
2741               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2742         }
2743     }
2744
2745
2746     /* we create the packets as a tree of kbnodes. Because the structure
2747      * we create is known in advance we simply generate a linked list
2748      * The first packet is a dummy comment packet which we flag
2749      * as deleted.  The very first packet must always be a KEY packet.
2750      */
2751     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
2752     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
2753
2754     if (!card)
2755       {
2756         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2757                         get_parameter_uint( para, pKEYLENGTH ),
2758                         pub_root, sec_root,
2759                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2760                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2761                         &pri_sk,
2762                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
2763       }
2764     else
2765       {
2766         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root,
2767                            get_parameter_u32 (para, pKEYEXPIRE), para);
2768         if (!rc)
2769           {
2770             pri_sk = sec_root->next->pkt->pkt.secret_key;
2771             assert (pri_sk);
2772           }
2773       }
2774
2775     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2776       {
2777         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
2778         if(!rc)
2779           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
2780       }
2781
2782     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
2783         write_uid(pub_root, s );
2784         if( !rc )
2785             write_uid(sec_root, s );
2786         if( !rc )
2787             rc = write_selfsig(pub_root, pub_root, pri_sk,
2788                                get_parameter_uint (para, pKEYUSAGE));
2789         if( !rc )
2790             rc = write_selfsig(sec_root, pub_root, pri_sk,
2791                                get_parameter_uint (para, pKEYUSAGE));
2792     }
2793
2794     if( get_parameter( para, pSUBKEYTYPE ) )
2795       {
2796         if (!card)
2797           {
2798             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2799                             get_parameter_uint( para, pSUBKEYLENGTH ),
2800                             pub_root, sec_root,
2801                             get_parameter_dek( para, pPASSPHRASE_DEK ),
2802                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
2803                             &sub_sk,
2804                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
2805           }
2806         else
2807           {
2808             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
2809               {
2810                 /* A backup of the encryption key has been requested.
2811                    Generate the key i software and import it then to
2812                    the card.  Write a backup file. */
2813                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
2814                                                pub_root, sec_root,
2815                                                get_parameter_u32 (para,
2816                                                                   pKEYEXPIRE),
2817                                                para, s);
2818               }
2819             else
2820               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
2821                                  get_parameter_u32 (para, pKEYEXPIRE), para);
2822           }
2823
2824         if( !rc )
2825           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
2826                                 get_parameter_uint (para, pSUBKEYUSAGE));
2827         if( !rc )
2828           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
2829                                 get_parameter_uint (para, pSUBKEYUSAGE));
2830         did_sub = 1;
2831       }
2832
2833     if (card && get_parameter (para, pAUTHKEYTYPE))
2834       {
2835         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root,
2836                            get_parameter_u32 (para, pKEYEXPIRE), para);
2837         
2838         if (!rc)
2839           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2840         if (!rc)
2841           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2842       }
2843     
2844     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2845         rc = write_keyblock( outctrl->pub.stream, pub_root );
2846         if( rc )
2847             log_error("can't write public key: %s\n", g10_errstr(rc) );
2848         if( !rc ) {
2849             rc = write_keyblock( outctrl->sec.stream, sec_root );
2850             if( rc )
2851                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2852         }
2853
2854     }
2855     else if( !rc ) { /* write to the standard keyrings */
2856         KEYDB_HANDLE pub_hd = keydb_new (0);
2857         KEYDB_HANDLE sec_hd = keydb_new (1);
2858
2859         /* FIXME: we may have to create the keyring first */
2860         rc = keydb_locate_writable (pub_hd, NULL);
2861         if (rc) 
2862             log_error (_("no writable public keyring found: %s\n"),
2863                        g10_errstr (rc));
2864
2865         if (!rc) {  
2866             rc = keydb_locate_writable (sec_hd, NULL);
2867             if (rc) 
2868                 log_error (_("no writable secret keyring found: %s\n"),
2869                            g10_errstr (rc));
2870         }
2871
2872         if (!rc && opt.verbose) {
2873             log_info(_("writing public key to `%s'\n"),
2874                      keydb_get_resource_name (pub_hd));
2875             if (card)
2876               log_info (_("writing secret key stub to `%s'\n"),
2877                         keydb_get_resource_name (sec_hd));
2878             else
2879               log_info(_("writing secret key to `%s'\n"),
2880                        keydb_get_resource_name (sec_hd));
2881         }
2882
2883         if (!rc) {
2884             rc = keydb_insert_keyblock (pub_hd, pub_root);
2885             if (rc)
2886                 log_error (_("error writing public keyring `%s': %s\n"),
2887                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2888         }
2889
2890         if (!rc) {
2891             rc = keydb_insert_keyblock (sec_hd, sec_root);
2892             if (rc)
2893                 log_error (_("error writing secret keyring `%s': %s\n"),
2894                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2895         }
2896
2897         keydb_release (pub_hd);
2898         keydb_release (sec_hd);
2899
2900         if (!rc) {
2901             int no_enc_rsa =
2902                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2903                 && get_parameter_uint( para, pKEYUSAGE )
2904                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2905             PKT_public_key *pk = find_kbnode (pub_root, 
2906                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2907
2908             keyid_from_pk(pk,pk->main_keyid);
2909             register_trusted_keyid(pk->main_keyid);
2910
2911             update_ownertrust (pk,
2912                                ((get_ownertrust (pk) & ~TRUST_MASK)
2913                                 | TRUST_ULTIMATE ));
2914
2915             if (!opt.batch) {
2916                 tty_printf(_("public and secret key created and signed.\n") );
2917                 tty_printf("\n");
2918                 list_keyblock(pub_root,0,1,NULL);
2919             }
2920             
2921
2922             if( !opt.batch
2923                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2924                      || no_enc_rsa )
2925                 && !get_parameter( para, pSUBKEYTYPE ) )
2926             {
2927                 tty_printf(_("Note that this key cannot be used for "
2928                              "encryption.  You may want to use\n"
2929                              "the command \"--edit-key\" to generate a "
2930                              "secondary key for this purpose.\n") );
2931             }
2932         }
2933     }
2934
2935     if( rc ) {
2936         if( opt.batch )
2937             log_error("key generation failed: %s\n", g10_errstr(rc) );
2938         else
2939             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2940         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
2941     }
2942     else {
2943         PKT_public_key *pk = find_kbnode (pub_root, 
2944                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2945         print_status_key_created (did_sub? 'B':'P', pk,
2946                                   get_parameter_value (para, pHANDLE));
2947     }
2948     release_kbnode( pub_root );
2949     release_kbnode( sec_root );
2950
2951     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
2952       free_secret_key(pri_sk); /* shallow copy in card mode. */
2953     if( sub_sk )
2954         free_secret_key(sub_sk);
2955 }
2956
2957
2958 /****************
2959  * add a new subkey to an existing key.
2960  * Returns true if a new key has been generated and put into the keyblocks.
2961  */
2962 int
2963 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2964 {
2965     int okay=0, rc=0;
2966     KBNODE node;
2967     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2968     int algo;
2969     unsigned int use;
2970     u32 expire;
2971     unsigned nbits;
2972     char *passphrase = NULL;
2973     DEK *dek = NULL;
2974     STRING2KEY *s2k = NULL;
2975     u32 cur_time;
2976
2977     /* break out the primary secret key */
2978     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2979     if( !node ) {
2980         log_error("Oops; secret key not found anymore!\n");
2981         goto leave;
2982     }
2983
2984     /* make a copy of the sk to keep the protected one in the keyblock */
2985     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
2986
2987     cur_time = make_timestamp();
2988     if( pri_sk->timestamp > cur_time ) {
2989         ulong d = pri_sk->timestamp - cur_time;
2990         log_info( d==1 ? _("key has been created %lu second "
2991                            "in future (time warp or clock problem)\n")
2992                        : _("key has been created %lu seconds "
2993                            "in future (time warp or clock problem)\n"), d );
2994         if( !opt.ignore_time_conflict ) {
2995             rc = G10ERR_TIME_CONFLICT;
2996             goto leave;
2997         }
2998     }
2999
3000     if (pri_sk->version < 4) {
3001         log_info (_("NOTE: creating subkeys for v3 keys "
3002                     "is not OpenPGP compliant\n"));
3003         goto leave;
3004     }
3005
3006     /* unprotect to get the passphrase */
3007     switch( is_secret_key_protected( pri_sk ) ) {
3008       case -1:
3009         rc = G10ERR_PUBKEY_ALGO;
3010         break;
3011       case 0:
3012         tty_printf("This key is not protected.\n");
3013         break;
3014       default:
3015         tty_printf("Key is protected.\n");
3016         rc = check_secret_key( pri_sk, 0 );
3017         if( !rc )
3018             passphrase = get_last_passphrase();
3019         break;
3020     }
3021     if( rc )
3022         goto leave;
3023
3024     algo = ask_algo( 1, &use );
3025     assert(algo);
3026     nbits = ask_keysize( algo );
3027     expire = ask_expire_interval(0);
3028     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3029                                                   _("Really create? (y/N) ")))
3030         goto leave;
3031
3032     if( passphrase ) {
3033         s2k = m_alloc_secure( sizeof *s2k );
3034         s2k->mode = opt.s2k_mode;
3035         s2k->hash_algo = S2K_DIGEST_ALGO;
3036         set_next_passphrase( passphrase );
3037         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3038                                  NULL, NULL );
3039     }
3040
3041     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
3042                                       dek, s2k, &sub_sk, expire, 1 );
3043     if( !rc )
3044         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3045     if( !rc )
3046         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3047     if( !rc ) {
3048         okay = 1;
3049         write_status_text (STATUS_KEY_CREATED, "S");
3050     }
3051
3052   leave:
3053     if( rc )
3054         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3055     m_free( passphrase );
3056     m_free( dek );
3057     m_free( s2k );
3058     /* release the copy of the (now unprotected) secret keys */
3059     if( pri_sk )
3060         free_secret_key(pri_sk);
3061     if( sub_sk )
3062         free_secret_key(sub_sk);
3063     set_next_passphrase( NULL );
3064     return okay;
3065 }
3066
3067
3068 #ifdef ENABLE_CARD_SUPPORT
3069 /* Generate a subkey on a card. */
3070 int
3071 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3072                           int keyno, const char *serialno)
3073 {
3074   int okay=0, rc=0;
3075   KBNODE node;
3076   PKT_secret_key *pri_sk = NULL;
3077   int algo;
3078   unsigned int use;
3079   u32 expire;
3080   char *passphrase = NULL;
3081   u32 cur_time;
3082   struct para_data_s *para = NULL;
3083
3084   assert (keyno >= 1 && keyno <= 3);
3085
3086   para = xcalloc (1, sizeof *para + strlen (serialno) );
3087   para->key = pSERIALNO;
3088   strcpy (para->u.value, serialno);
3089
3090   /* Break out the primary secret key */
3091   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3092   if(!node)
3093     {
3094       log_error("Oops; secret key not found anymore!\n");
3095       goto leave;
3096     }
3097
3098   /* Make a copy of the sk to keep the protected one in the keyblock */
3099   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3100
3101   cur_time = make_timestamp();
3102   if (pri_sk->timestamp > cur_time)
3103     {
3104       ulong d = pri_sk->timestamp - cur_time;
3105       log_info (d==1 ? _("key has been created %lu second "
3106                          "in future (time warp or clock problem)\n")
3107                      : _("key has been created %lu seconds "
3108                          "in future (time warp or clock problem)\n"), d );
3109         if (!opt.ignore_time_conflict)
3110           {
3111             rc = G10ERR_TIME_CONFLICT;
3112             goto leave;
3113           }
3114     }
3115
3116   if (pri_sk->version < 4)
3117     {
3118       log_info (_("NOTE: creating subkeys for v3 keys "
3119                   "is not OpenPGP compliant\n"));
3120       goto leave;
3121     }
3122
3123   /* Unprotect to get the passphrase. */
3124   switch( is_secret_key_protected (pri_sk) )
3125     {
3126     case -1:
3127       rc = G10ERR_PUBKEY_ALGO;
3128       break;
3129     case 0:
3130       tty_printf("This key is not protected.\n");
3131       break;
3132     default:
3133       tty_printf("Key is protected.\n");
3134       rc = check_secret_key( pri_sk, 0 );
3135       if (!rc)
3136         passphrase = get_last_passphrase();
3137       break;
3138     }
3139   if (rc)
3140     goto leave;
3141
3142   algo = PUBKEY_ALGO_RSA;
3143   expire = ask_expire_interval (0);
3144   if (keyno == 1)
3145     use = PUBKEY_USAGE_SIG;
3146   else if (keyno == 2)
3147     use = PUBKEY_USAGE_ENC;
3148   else
3149     use = PUBKEY_USAGE_AUTH;
3150   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3151                                                _("Really create? (y/N) ")))
3152     goto leave;
3153
3154   if (passphrase)
3155     set_next_passphrase (passphrase);
3156   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock, expire, para);
3157   if (!rc)
3158     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, NULL, use);
3159   if (!rc)
3160     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, NULL, use);
3161   if (!rc)
3162     {
3163       okay = 1;
3164       write_status_text (STATUS_KEY_CREATED, "S");
3165     }
3166
3167  leave:
3168   if (rc)
3169     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3170   m_free (passphrase);
3171   /* Release the copy of the (now unprotected) secret keys. */
3172   if (pri_sk)
3173     free_secret_key (pri_sk);
3174   set_next_passphrase( NULL );
3175   release_parameter_list (para);
3176   return okay;
3177 }
3178 #endif /* !ENABLE_CARD_SUPPORT */
3179
3180
3181 /****************
3182  * Write a keyblock to an output stream
3183  */
3184 static int
3185 write_keyblock( IOBUF out, KBNODE node )
3186 {
3187     for( ; node ; node = node->next ) {
3188         int rc = build_packet( out, node->pkt );
3189         if( rc ) {
3190             log_error("build_packet(%d) failed: %s\n",
3191                         node->pkt->pkttype, g10_errstr(rc) );
3192             return G10ERR_WRITE_FILE;
3193         }
3194     }
3195     return 0;
3196 }
3197
3198
3199 static int
3200 gen_card_key (int algo, int keyno, int is_primary,
3201               KBNODE pub_root, KBNODE sec_root,
3202               u32 expireval, struct para_data_s *para)
3203 {
3204 #ifdef ENABLE_CARD_SUPPORT
3205   int rc;
3206   const char *s;
3207   struct agent_card_genkey_s info;
3208   PACKET *pkt;
3209   PKT_secret_key *sk;
3210   PKT_public_key *pk;
3211
3212   assert (algo == PUBKEY_ALGO_RSA);
3213   
3214
3215   rc = agent_scd_genkey (&info, keyno, 1);
3216 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3217 /*      { */
3218 /*        tty_printf ("\n"); */
3219 /*        log_error ("WARNING: key does already exists!\n"); */
3220 /*        tty_printf ("\n"); */
3221 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3222 /*                                    _("Replace existing key? "))) */
3223 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3224 /*      } */
3225
3226   if (rc)
3227     {
3228       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3229       return rc;
3230     }
3231   if ( !info.n || !info.e )
3232     {
3233       log_error ("communication error with SCD\n");
3234       mpi_free (info.n);
3235       mpi_free (info.e);
3236       return gpg_error (GPG_ERR_GENERAL);
3237     }
3238   
3239
3240   pk = xcalloc (1, sizeof *pk );
3241   sk = xcalloc (1, sizeof *sk );
3242   sk->timestamp = pk->timestamp = info.created_at;
3243   sk->version = pk->version = 4;
3244   if (expireval)
3245       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3246   sk->pubkey_algo = pk->pubkey_algo = algo;
3247   pk->pkey[0] = info.n;
3248   pk->pkey[1] = info.e; 
3249   sk->skey[0] = mpi_copy (pk->pkey[0]);
3250   sk->skey[1] = mpi_copy (pk->pkey[1]);
3251   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3252   sk->is_protected = 1;
3253   sk->protect.s2k.mode = 1002;
3254   s = get_parameter_value (para, pSERIALNO);
3255   if (s)
3256     {
3257       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3258            sk->protect.ivlen++, s += 2)
3259         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3260     }
3261
3262   pkt = xcalloc (1,sizeof *pkt);
3263   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3264   pkt->pkt.public_key = pk;
3265   add_kbnode(pub_root, new_kbnode( pkt ));
3266
3267   pkt = xcalloc (1,sizeof *pkt);
3268   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3269   pkt->pkt.secret_key = sk;
3270   add_kbnode(sec_root, new_kbnode( pkt ));
3271
3272   return 0;
3273 #else
3274   return -1;
3275 #endif /*!ENABLE_CARD_SUPPORT*/
3276 }
3277
3278
3279
3280 static int
3281 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3282                           KBNODE pub_root, KBNODE sec_root,
3283                           u32 expireval, struct para_data_s *para,
3284                           const char *backup_dir)
3285 {
3286 #ifdef ENABLE_CARD_SUPPORT
3287   int rc;
3288   const char *s;
3289   PACKET *pkt;
3290   PKT_secret_key *sk, *sk_unprotected, *sk_protected;
3291   PKT_public_key *pk;
3292   size_t n;
3293   int i;
3294
3295   rc = generate_raw_key (algo, 1024, make_timestamp (),
3296                          &sk_unprotected, &sk_protected);
3297   if (rc)
3298     return rc;
3299
3300   /* First, store the key to the card. */
3301   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3302   if (rc)
3303     {
3304       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3305       free_secret_key (sk_unprotected);
3306       free_secret_key (sk_protected);
3307       return rc;
3308     }
3309
3310   /* Get rid of the secret key parameters and store the serial numer. */
3311   sk = sk_unprotected;
3312   n = pubkey_get_nskey (sk->pubkey_algo);
3313   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3314     {
3315       mpi_free (sk->skey[i]);
3316       sk->skey[i] = NULL;
3317     }
3318   i = pubkey_get_npkey (sk->pubkey_algo);
3319   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3320   sk->is_protected = 1;
3321   sk->protect.s2k.mode = 1002;
3322   s = get_parameter_value (para, pSERIALNO);
3323   assert (s);
3324   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3325        sk->protect.ivlen++, s += 2)
3326     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3327
3328   /* Now write the *protected* secret key to the file.  */
3329   {
3330     char name_buffer[50];
3331     char *fname;
3332     IOBUF fp;
3333     mode_t oldmask;
3334
3335     keyid_from_sk (sk, NULL);
3336     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
3337              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3338
3339     fname = make_filename (backup_dir, name_buffer, NULL);
3340     oldmask = umask (077);
3341     if (is_secured_filename (fname))
3342       {
3343         fp = NULL;
3344         errno = EPERM;
3345       }
3346     else
3347       fp = iobuf_create (fname);
3348     umask (oldmask);
3349     if (!fp) 
3350       {
3351         log_error (_("can't create backup file `%s': %s\n"),
3352                    fname, strerror(errno) );
3353         m_free (fname);
3354         free_secret_key (sk_unprotected);
3355         free_secret_key (sk_protected);
3356         return G10ERR_OPEN_FILE;
3357       }
3358
3359     pkt = xcalloc (1, sizeof *pkt);
3360     pkt->pkttype = PKT_SECRET_KEY;
3361     pkt->pkt.secret_key = sk_protected;
3362     sk_protected = NULL;
3363
3364     rc = build_packet (fp, pkt);
3365     if (rc)
3366       {
3367         log_error("build packet failed: %s\n", g10_errstr(rc) );
3368         iobuf_cancel (fp);
3369       }
3370     else
3371       {
3372         iobuf_close (fp);
3373         iobuf_ioctl (NULL, 2, 0, (char*)fname);
3374         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3375       }
3376     free_packet (pkt);
3377     m_free (pkt);
3378     m_free (fname);
3379     if (rc)
3380       {
3381         free_secret_key (sk_unprotected);
3382         return rc;
3383       }
3384   }
3385
3386   /* Create the public key from the secret key. */
3387   pk = xcalloc (1, sizeof *pk );
3388   pk->timestamp = sk->timestamp;
3389   pk->version = sk->version;
3390   if (expireval)
3391       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3392   pk->pubkey_algo = sk->pubkey_algo;
3393   n = pubkey_get_npkey (sk->pubkey_algo);
3394   for (i=0; i < n; i++)
3395     pk->pkey[i] = mpi_copy (sk->skey[i]);
3396
3397   /* Build packets and add them to the node lists.  */
3398   pkt = xcalloc (1,sizeof *pkt);
3399   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3400   pkt->pkt.public_key = pk;
3401   add_kbnode(pub_root, new_kbnode( pkt ));
3402
3403   pkt = xcalloc (1,sizeof *pkt);
3404   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3405   pkt->pkt.secret_key = sk;
3406   add_kbnode(sec_root, new_kbnode( pkt ));
3407
3408   return 0;
3409 #else
3410   return -1;
3411 #endif /*!ENABLE_CARD_SUPPORT*/
3412 }
3413
3414
3415 #ifdef ENABLE_CARD_SUPPORT
3416 int
3417 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3418 {
3419   int rc;
3420   size_t n;
3421   MPI rsa_n, rsa_e, rsa_p, rsa_q;
3422   unsigned int nbits;
3423   unsigned char *template = NULL;
3424   unsigned char *tp;
3425   unsigned char m[128], e[4];
3426   size_t mlen, elen;
3427
3428   assert (is_RSA (sk->pubkey_algo));
3429   assert (!sk->is_protected);
3430
3431   rc = -1;
3432   /* Some basic checks on the key parameters. */
3433   rsa_n = sk->skey[0];
3434   rsa_e = sk->skey[1];
3435   rsa_p = sk->skey[3];
3436   rsa_q = sk->skey[4];
3437
3438   nbits = GET_NBITS (rsa_n);
3439   if (nbits != 1024)
3440     {
3441       log_error (_("length of RSA modulus is not %d\n"), 1024);
3442       goto leave;
3443     }
3444   nbits = GET_NBITS (rsa_e);
3445   if (nbits < 2 || nbits > 32)
3446     {
3447       log_error (_("public exponent too large (more than 32 bits)\n"));
3448       goto leave;
3449     }
3450   nbits = GET_NBITS (rsa_p);
3451   if (nbits != 512)
3452     {
3453       log_error (_("length of an RSA prime is not %d\n"), 512);
3454       goto leave;
3455     }
3456   nbits = GET_NBITS (rsa_q);
3457   if (nbits != 512)
3458     {
3459       log_error (_("length of an RSA prime is not %d\n"), 512);
3460       goto leave;
3461     }
3462
3463   
3464   /* We need the modulus later to calculate the fingerprint. */
3465   rc = copy_mpi (rsa_n, m, 128, &n);
3466   if (rc)
3467     goto leave;
3468   assert (n == 128);
3469   mlen = 128;
3470
3471   /* Build the private key template as described in section 4.3.3.6 of
3472      the OpenPGP card specs:
3473          0xC0   <length> public exponent
3474          0xC1   <length> prime p 
3475          0xC2   <length> prime q 
3476   */
3477   template = tp = xmalloc_secure (1+2 + 1+1+4 + 1+1+(512/8) + 1+1+(512/8));
3478   *tp++ = 0xC0;
3479   *tp++ = 4;
3480   rc = copy_mpi (rsa_e, tp, 4, &n);
3481   if (rc)
3482     goto leave;
3483   assert (n <= 4);
3484   memcpy (e, tp, n);  /* Save a copy of the exponent for later use.  */
3485   elen = n;
3486   if (n != 4)
3487     {
3488       memmove (tp+4-n, tp, 4-n);
3489       memset (tp, 0, 4-n);
3490     }                 
3491   tp += 4;
3492
3493   *tp++ = 0xC1;
3494   *tp++ = 64;
3495   rc = copy_mpi (rsa_p, tp, 64, &n);
3496   if (rc)
3497     goto leave;
3498   assert (n == 64);
3499   tp += 64;
3500
3501   *tp++ = 0xC2;
3502   *tp++ = 64;
3503   rc = copy_mpi (rsa_q, tp, 64, &n);
3504   if (rc)
3505     goto leave;
3506   assert (n == 64);
3507   tp += 64;
3508   assert (tp - template == 138);
3509
3510   rc = agent_openpgp_storekey (keyno,
3511                                template, tp - template,
3512                                sk->timestamp,
3513                                m, mlen,
3514                                e, elen);
3515
3516  leave:
3517   xfree (template);
3518   return rc;
3519 }
3520 #endif /*ENABLE_CARD_SUPPORT*/