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