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