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