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