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