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