* keygen.c (write_selfsigs): Rename from write_selfsig. Write the same
[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_selfsigs( KBNODE sec_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( pub_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( sec_root, new_kbnode( pkt ) );
925
926     pkt = m_alloc_clear( sizeof *pkt );
927     pkt->pkttype = PKT_SIGNATURE;
928     pkt->pkt.signature = copy_signature(NULL,sig);
929     add_kbnode( pub_root, new_kbnode( pkt ) );
930     return rc;
931 }
932
933 /* sub_sk is currently unused (reserved for backsigs) */
934 static int
935 write_keybinding( KBNODE root, KBNODE pub_root,
936                   PKT_secret_key *pri_sk, PKT_secret_key *sub_sk,
937                   unsigned int use )
938 {
939     PACKET *pkt;
940     PKT_signature *sig;
941     int rc=0;
942     KBNODE node;
943     PKT_public_key *pri_pk, *sub_pk;
944     struct opaque_data_usage_and_pk oduap;
945
946     if( opt.verbose )
947         log_info(_("writing key binding signature\n"));
948
949     /* get the pk packet from the pub_tree */
950     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
951     if( !node )
952         BUG();
953     pri_pk = node->pkt->pkt.public_key;
954     /* we have to cache the key, so that the verification of the signature
955      * creation is able to retrieve the public key */
956     cache_public_key (pri_pk);
957  
958     /* find the last subkey */
959     sub_pk = NULL;
960     for(node=pub_root; node; node = node->next ) {
961         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
962             sub_pk = node->pkt->pkt.public_key;
963     }
964     if( !sub_pk )
965         BUG();
966
967     /* and make the signature */
968     oduap.usage = use;
969     oduap.pk = sub_pk;
970     rc=make_keysig_packet(&sig, pri_pk, NULL, sub_pk, pri_sk, 0x18, 0, 0, 0, 0,
971                           keygen_add_key_flags_and_expire, &oduap );
972     if( rc ) {
973         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
974         return rc;
975     }
976
977     /* make a backsig */
978     if(use&PUBKEY_USAGE_SIG)
979       {
980         rc=make_backsig(sig,pri_pk,sub_pk,sub_sk);
981         if(rc)
982           return rc;
983       }
984
985     pkt = m_alloc_clear( sizeof *pkt );
986     pkt->pkttype = PKT_SIGNATURE;
987     pkt->pkt.signature = sig;
988     add_kbnode( root, new_kbnode( pkt ) );
989     return rc;
990 }
991
992
993 static int
994 gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
995         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
996 {
997     int rc;
998     PACKET *pkt;
999     PKT_secret_key *sk;
1000     PKT_public_key *pk;
1001     MPI skey[4];
1002     MPI *factors;
1003
1004     assert( is_ELGAMAL(algo) );
1005
1006     if( nbits < 512 ) {
1007         nbits = 1024;
1008         log_info(_("keysize invalid; using %u bits\n"), nbits );
1009     }
1010
1011     if( (nbits % 32) ) {
1012         nbits = ((nbits + 31) / 32) * 32;
1013         log_info(_("keysize rounded up to %u bits\n"), nbits );
1014     }
1015
1016     rc = pubkey_generate( algo, nbits, skey, &factors );
1017     if( rc ) {
1018         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
1019         return rc;
1020     }
1021
1022     sk = m_alloc_clear( sizeof *sk );
1023     pk = m_alloc_clear( sizeof *pk );
1024     sk->timestamp = pk->timestamp = make_timestamp();
1025     sk->version = pk->version = 4;
1026     if( expireval ) {
1027         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1028     }
1029     sk->pubkey_algo = pk->pubkey_algo = algo;
1030                        pk->pkey[0] = mpi_copy( skey[0] );
1031                        pk->pkey[1] = mpi_copy( skey[1] );
1032                        pk->pkey[2] = mpi_copy( skey[2] );
1033     sk->skey[0] = skey[0];
1034     sk->skey[1] = skey[1];
1035     sk->skey[2] = skey[2];
1036     sk->skey[3] = skey[3];
1037     sk->is_protected = 0;
1038     sk->protect.algo = 0;
1039
1040     sk->csum = checksum_mpi( sk->skey[3] );
1041     if( ret_sk ) /* return an unprotected version of the sk */
1042         *ret_sk = copy_secret_key( NULL, sk );
1043
1044     if( dek ) {
1045         sk->protect.algo = dek->algo;
1046         sk->protect.s2k = *s2k;
1047         rc = protect_secret_key( sk, dek );
1048         if( rc ) {
1049             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1050             free_public_key(pk);
1051             free_secret_key(sk);
1052             return rc;
1053         }
1054     }
1055
1056     pkt = m_alloc_clear(sizeof *pkt);
1057     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1058     pkt->pkt.public_key = pk;
1059     add_kbnode(pub_root, new_kbnode( pkt ));
1060
1061     /* don't know whether it makes sense to have the factors, so for now
1062      * we store them in the secret keyring (but they are not secret) */
1063     pkt = m_alloc_clear(sizeof *pkt);
1064     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1065     pkt->pkt.secret_key = sk;
1066     add_kbnode(sec_root, new_kbnode( pkt ));
1067
1068     return 0;
1069 }
1070
1071
1072 /****************
1073  * Generate a DSA key
1074  */
1075 static int
1076 gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1077         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
1078 {
1079     int rc;
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
1154     return 0;
1155 }
1156
1157
1158 /* 
1159  * Generate an RSA key.
1160  */
1161 static int
1162 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1163         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
1164 {
1165     int rc;
1166     PACKET *pkt;
1167     PKT_secret_key *sk;
1168     PKT_public_key *pk;
1169     MPI skey[6];
1170     MPI *factors;
1171
1172     assert( is_RSA(algo) );
1173
1174     if( nbits < 1024 ) {
1175         nbits = 1024;
1176         log_info(_("keysize invalid; using %u bits\n"), nbits );
1177     }
1178
1179     if( (nbits % 32) ) {
1180         nbits = ((nbits + 31) / 32) * 32;
1181         log_info(_("keysize rounded up to %u bits\n"), nbits );
1182     }
1183
1184     rc = pubkey_generate( algo, nbits, skey, &factors );
1185     if( rc ) {
1186         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
1187         return rc;
1188     }
1189
1190     sk = m_alloc_clear( sizeof *sk );
1191     pk = m_alloc_clear( sizeof *pk );
1192     sk->timestamp = pk->timestamp = make_timestamp();
1193     sk->version = pk->version = 4;
1194     if( expireval ) {
1195         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1196     }
1197     sk->pubkey_algo = pk->pubkey_algo = algo;
1198                        pk->pkey[0] = mpi_copy( skey[0] );
1199                        pk->pkey[1] = mpi_copy( skey[1] );
1200     sk->skey[0] = skey[0];
1201     sk->skey[1] = skey[1];
1202     sk->skey[2] = skey[2];
1203     sk->skey[3] = skey[3];
1204     sk->skey[4] = skey[4];
1205     sk->skey[5] = skey[5];
1206     sk->is_protected = 0;
1207     sk->protect.algo = 0;
1208
1209     sk->csum  = checksum_mpi (sk->skey[2] );
1210     sk->csum += checksum_mpi (sk->skey[3] );
1211     sk->csum += checksum_mpi (sk->skey[4] );
1212     sk->csum += checksum_mpi (sk->skey[5] );
1213     if( ret_sk ) /* return an unprotected version of the sk */
1214         *ret_sk = copy_secret_key( NULL, sk );
1215
1216     if( dek ) {
1217         sk->protect.algo = dek->algo;
1218         sk->protect.s2k = *s2k;
1219         rc = protect_secret_key( sk, dek );
1220         if( rc ) {
1221             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1222             free_public_key(pk);
1223             free_secret_key(sk);
1224             return rc;
1225         }
1226     }
1227
1228     pkt = m_alloc_clear(sizeof *pkt);
1229     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1230     pkt->pkt.public_key = pk;
1231     add_kbnode(pub_root, new_kbnode( pkt ));
1232
1233     pkt = m_alloc_clear(sizeof *pkt);
1234     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1235     pkt->pkt.secret_key = sk;
1236     add_kbnode(sec_root, new_kbnode( pkt ));
1237
1238     return 0;
1239 }
1240
1241
1242 /****************
1243  * check valid days:
1244  * return 0 on error or the multiplier
1245  */
1246 static int
1247 check_valid_days( const char *s )
1248 {
1249     if( !digitp(s) )
1250         return 0;
1251     for( s++; *s; s++)
1252         if( !digitp(s) )
1253             break;
1254     if( !*s )
1255         return 1;
1256     if( s[1] )
1257         return 0; /* e.g. "2323wc" */
1258     if( *s == 'd' || *s == 'D' )
1259         return 1;
1260     if( *s == 'w' || *s == 'W' )
1261         return 7;
1262     if( *s == 'm' || *s == 'M' )
1263         return 30;
1264     if( *s == 'y' || *s == 'Y' )
1265         return 365;
1266     return 0;
1267 }
1268
1269
1270 static void
1271 print_key_flags(int flags)
1272 {
1273   if(flags&PUBKEY_USAGE_SIG)
1274     tty_printf("%s ",_("Sign"));
1275
1276   if(flags&PUBKEY_USAGE_ENC)
1277     tty_printf("%s ",_("Encrypt"));
1278
1279   if(flags&PUBKEY_USAGE_AUTH)
1280     tty_printf("%s ",_("Authenticate"));
1281 }
1282
1283
1284 /* Returns the key flags */
1285 static unsigned int
1286 ask_key_flags(int algo)
1287 {
1288   const char *togglers=_("SsEeAaQq");
1289   char *answer=NULL;
1290   unsigned int current=0;
1291   unsigned int possible=openpgp_pk_algo_usage(algo);
1292
1293   if(strlen(togglers)!=8)
1294     BUG();
1295
1296   /* Preload the current set with the possible set, minus
1297      authentication, since nobody really uses auth yet. */
1298   current=possible&~PUBKEY_USAGE_AUTH;
1299
1300   for(;;)
1301     {
1302       tty_printf("\n");
1303       tty_printf(_("Possible actions for a %s key: "),
1304                  pubkey_algo_to_string(algo));
1305       print_key_flags(possible);
1306       tty_printf("\n");
1307       tty_printf(_("Current allowed actions: "));
1308       print_key_flags(current);
1309       tty_printf("\n\n");
1310
1311       if(possible&PUBKEY_USAGE_SIG)
1312         tty_printf(_("   (%c) Toggle the sign capability\n"),
1313                    togglers[0]);
1314       if(possible&PUBKEY_USAGE_ENC)
1315         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1316                    togglers[2]);
1317       if(possible&PUBKEY_USAGE_AUTH)
1318         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1319                    togglers[4]);
1320
1321       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1322       tty_printf("\n");
1323
1324       m_free(answer);
1325       answer = cpr_get("keygen.flags",_("Your selection? "));
1326       cpr_kill_prompt();
1327
1328       if(strlen(answer)>1)
1329         continue;
1330       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1331         break;
1332       else if((*answer==togglers[0] || *answer==togglers[1])
1333               && possible&PUBKEY_USAGE_SIG)
1334         {
1335           if(current&PUBKEY_USAGE_SIG)
1336             current&=~PUBKEY_USAGE_SIG;
1337           else
1338             current|=PUBKEY_USAGE_SIG;
1339         }
1340       else if((*answer==togglers[2] || *answer==togglers[3])
1341               && possible&PUBKEY_USAGE_ENC)
1342         {
1343           if(current&PUBKEY_USAGE_ENC)
1344             current&=~PUBKEY_USAGE_ENC;
1345           else
1346             current|=PUBKEY_USAGE_ENC;
1347         }
1348       else if((*answer==togglers[4] || *answer==togglers[5])
1349               && possible&PUBKEY_USAGE_AUTH)
1350         {
1351           if(current&PUBKEY_USAGE_AUTH)
1352             current&=~PUBKEY_USAGE_AUTH;
1353           else
1354             current|=PUBKEY_USAGE_AUTH;
1355         }
1356     }
1357
1358   m_free(answer);
1359
1360   return current;
1361 }
1362
1363
1364 /****************
1365  * Returns: 0 to create both a DSA and a Elgamal key.
1366  *          and only if key flags are to be written the desired usage.
1367  */
1368 static int
1369 ask_algo (int addmode, unsigned int *r_usage)
1370 {
1371     char *answer;
1372     int algo;
1373
1374     *r_usage = 0;
1375     tty_printf(_("Please select what kind of key you want:\n"));
1376     if( !addmode )
1377         tty_printf(_("   (%d) DSA and Elgamal (default)\n"), 1 );
1378     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
1379     if (opt.expert)
1380       tty_printf(  _("   (%d) DSA (set your own capabilities)\n"), 3 );
1381     if( addmode )
1382         tty_printf(_("   (%d) Elgamal (encrypt only)\n"), 4 );
1383     tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
1384     if (addmode)
1385         tty_printf(_("   (%d) RSA (encrypt only)\n"), 6 );
1386     if (opt.expert)
1387       tty_printf(  _("   (%d) RSA (set your own capabilities)\n"), 7 );
1388
1389     for(;;) {
1390         answer = cpr_get("keygen.algo",_("Your selection? "));
1391         cpr_kill_prompt();
1392         algo = *answer? atoi(answer): 1;
1393         m_free(answer);
1394         if( algo == 1 && !addmode ) {
1395             algo = 0;   /* create both keys */
1396             break;
1397         }
1398         else if( algo == 7 && opt.expert ) {
1399             algo = PUBKEY_ALGO_RSA;
1400             *r_usage=ask_key_flags(algo);
1401             break;
1402         }
1403         else if( algo == 6 && addmode ) {
1404             algo = PUBKEY_ALGO_RSA;
1405             *r_usage = PUBKEY_USAGE_ENC;
1406             break;
1407         }
1408         else if( algo == 5 ) {
1409             algo = PUBKEY_ALGO_RSA;
1410             *r_usage = PUBKEY_USAGE_SIG;
1411             break;
1412         }
1413         else if( algo == 4 && addmode ) {
1414             algo = PUBKEY_ALGO_ELGAMAL_E;
1415             *r_usage = PUBKEY_USAGE_ENC;
1416             break;
1417         }
1418         else if( algo == 3 && opt.expert ) {
1419             algo = PUBKEY_ALGO_DSA;
1420             *r_usage=ask_key_flags(algo);
1421             break;
1422         }
1423         else if( algo == 2 ) {
1424             algo = PUBKEY_ALGO_DSA;
1425             *r_usage = PUBKEY_USAGE_SIG;
1426             break;
1427         }
1428         else
1429             tty_printf(_("Invalid selection.\n"));
1430     }
1431
1432     return algo;
1433 }
1434
1435
1436 static unsigned
1437 ask_keysize( int algo )
1438 {
1439   unsigned nbits,min,def=2048,max=4096;
1440
1441   if(opt.expert)
1442     min=512;
1443   else
1444     min=1024;
1445
1446   switch(algo)
1447     {
1448     case PUBKEY_ALGO_DSA:
1449       if(opt.expert)
1450         {
1451           def=1024;
1452           max=1024;
1453         }
1454       else
1455         {
1456           tty_printf(_("DSA keypair will have %u bits.\n"),1024);
1457           return 1024;
1458         }
1459       break;
1460
1461     case PUBKEY_ALGO_RSA:
1462       min=1024;
1463       break;
1464     }
1465
1466   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1467              pubkey_algo_to_string(algo),min,max);
1468
1469   for(;;)
1470     {
1471       char *prompt,*answer;
1472
1473 #define PROMPTSTRING _("What keysize do you want? (%u) ")
1474
1475       prompt=m_alloc(strlen(PROMPTSTRING)+20);
1476       sprintf(prompt,PROMPTSTRING,def);
1477
1478 #undef PROMPTSTRING
1479
1480       answer = cpr_get("keygen.size",prompt);
1481       cpr_kill_prompt();
1482       nbits = *answer? atoi(answer): def;
1483       m_free(prompt);
1484       m_free(answer);
1485       
1486       if(nbits<min || nbits>max)
1487         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1488                    pubkey_algo_to_string(algo),min,max);
1489       else
1490         break;
1491     }
1492
1493   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1494
1495   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1496     {
1497       nbits = ((nbits + 63) / 64) * 64;
1498       tty_printf(_("rounded up to %u bits\n"), nbits );
1499     }
1500   else if( (nbits % 32) )
1501     {
1502       nbits = ((nbits + 31) / 32) * 32;
1503       tty_printf(_("rounded up to %u bits\n"), nbits );
1504     }
1505
1506   return nbits;
1507 }
1508
1509
1510 /****************
1511  * Parse an expire string and return its value in seconds.
1512  * Returns (u32)-1 on error.
1513  * This isn't perfect since scan_isodatestr returns unix time, and
1514  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1515  * Because of this, we only permit setting expirations up to 2106, but
1516  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1517  * just cope for the next few years until we get a 64-bit time_t or
1518  * similar.
1519  */
1520 u32
1521 parse_expire_string( const char *string )
1522 {
1523     int mult;
1524     u32 seconds,abs_date=0,curtime = make_timestamp();
1525
1526     if( !*string )
1527       seconds = 0;
1528     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime )
1529       seconds = abs_date - curtime;
1530     else if( (mult=check_valid_days(string)) )
1531       seconds = atoi(string) * 86400L * mult;
1532     else
1533       seconds=(u32)-1;
1534
1535     return seconds;
1536 }
1537
1538 /* object == 0 for a key, and 1 for a sig */
1539 u32
1540 ask_expire_interval(int object,const char *def_expire)
1541 {
1542     u32 interval;
1543     char *answer;
1544
1545     switch(object)
1546       {
1547       case 0:
1548         if(def_expire)
1549           BUG();
1550         tty_printf(_("Please specify how long the key should be valid.\n"
1551                      "         0 = key does not expire\n"
1552                      "      <n>  = key expires in n days\n"
1553                      "      <n>w = key expires in n weeks\n"
1554                      "      <n>m = key expires in n months\n"
1555                      "      <n>y = key expires in n years\n"));
1556         break;
1557
1558       case 1:
1559         if(!def_expire)
1560           BUG();
1561         tty_printf(_("Please specify how long the signature should be valid.\n"
1562                      "         0 = signature does not expire\n"
1563                      "      <n>  = signature expires in n days\n"
1564                      "      <n>w = signature expires in n weeks\n"
1565                      "      <n>m = signature expires in n months\n"
1566                      "      <n>y = signature expires in n years\n"));
1567         break;
1568
1569       default:
1570         BUG();
1571       }
1572
1573     /* Note: The elgamal subkey for DSA has no expiration date because
1574      * it must be signed with the DSA key and this one has the expiration
1575      * date */
1576
1577     answer = NULL;
1578     for(;;)
1579       {
1580         u32 curtime=make_timestamp();
1581
1582         m_free(answer);
1583         if(object==0)
1584           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1585         else
1586           {
1587             char *prompt;
1588
1589 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1590             /* This will actually end up larger than necessary because
1591                of the 2 bytes for '%s' */
1592             prompt=m_alloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1593             sprintf(prompt,PROMPTSTRING,def_expire);
1594 #undef PROMPTSTRING
1595
1596             answer = cpr_get("siggen.valid",prompt);
1597             m_free(prompt);
1598
1599             if(*answer=='\0')
1600               answer=m_strdup(def_expire);
1601           }
1602         cpr_kill_prompt();
1603         trim_spaces(answer);
1604         interval = parse_expire_string( answer );
1605         if( interval == (u32)-1 )
1606           {
1607             tty_printf(_("invalid value\n"));
1608             continue;
1609           }
1610
1611         if( !interval )
1612           {
1613             tty_printf((object==0)
1614                        ? _("Key does not expire at all\n")
1615                        : _("Signature does not expire at all\n"));
1616           }
1617         else
1618           {
1619             tty_printf(object==0
1620                        ? _("Key expires at %s\n")
1621                        : _("Signature expires at %s\n"),
1622                        asctimestamp((ulong)(curtime + interval) ) );
1623             /* FIXME: This check yields warning on alhas: Write a
1624                configure check and to this check here only for 32 bit
1625                machines */
1626             if( (time_t)((ulong)(curtime+interval)) < 0 )
1627               tty_printf(_("Your system can't display dates beyond 2038.\n"
1628                            "However, it will be correctly handled up to 2106.\n"));
1629           }
1630
1631         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1632                                                    _("Is this correct? (y/N) ")) )
1633           break;
1634       }
1635
1636     m_free(answer);
1637     return interval;
1638 }
1639
1640 u32
1641 ask_expiredate()
1642 {
1643     u32 x = ask_expire_interval(0,NULL);
1644     return x? make_timestamp() + x : 0;
1645 }
1646
1647 static int
1648 has_invalid_email_chars( const char *s )
1649 {
1650     int at_seen=0;
1651     static char valid_chars[] = "01234567890_-."
1652                                 "abcdefghijklmnopqrstuvwxyz"
1653                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1654
1655     for( ; *s; s++ ) {
1656         if( *s & 0x80 )
1657             return 1;
1658         if( *s == '@' )
1659             at_seen=1;
1660         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1661             return 1;
1662         else if( at_seen && !strchr( valid_chars, *s ) )
1663             return 1;
1664     }
1665     return 0;
1666 }
1667
1668
1669 static char *
1670 ask_user_id( int mode )
1671 {
1672     char *answer;
1673     char *aname, *acomment, *amail, *uid;
1674
1675     if( !mode )
1676         tty_printf( _("\n"
1677 "You need a user ID to identify your key; "
1678                                         "the software constructs the user ID\n"
1679 "from the Real Name, Comment and Email Address in this form:\n"
1680 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1681     uid = aname = acomment = amail = NULL;
1682     for(;;) {
1683         char *p;
1684         int fail=0;
1685
1686         if( !aname ) {
1687             for(;;) {
1688                 m_free(aname);
1689                 aname = cpr_get("keygen.name",_("Real name: "));
1690                 trim_spaces(aname);
1691                 cpr_kill_prompt();
1692
1693                 if( opt.allow_freeform_uid )
1694                     break;
1695
1696                 if( strpbrk( aname, "<>" ) )
1697                     tty_printf(_("Invalid character in name\n"));
1698                 else if( digitp(aname) )
1699                     tty_printf(_("Name may not start with a digit\n"));
1700                 else if( strlen(aname) < 5 )
1701                     tty_printf(_("Name must be at least 5 characters long\n"));
1702                 else
1703                     break;
1704             }
1705         }
1706         if( !amail ) {
1707             for(;;) {
1708                 m_free(amail);
1709                 amail = cpr_get("keygen.email",_("Email address: "));
1710                 trim_spaces(amail);
1711                 cpr_kill_prompt();
1712                 if( !*amail || opt.allow_freeform_uid )
1713                     break;   /* no email address is okay */
1714                 else if( has_invalid_email_chars(amail)
1715                          || string_count_chr(amail,'@') != 1
1716                          || *amail == '@'
1717                          || amail[strlen(amail)-1] == '@'
1718                          || amail[strlen(amail)-1] == '.'
1719                          || strstr(amail, "..") )
1720                     tty_printf(_("Not a valid email address\n"));
1721                 else
1722                     break;
1723             }
1724         }
1725         if( !acomment ) {
1726             for(;;) {
1727                 m_free(acomment);
1728                 acomment = cpr_get("keygen.comment",_("Comment: "));
1729                 trim_spaces(acomment);
1730                 cpr_kill_prompt();
1731                 if( !*acomment )
1732                     break;   /* no comment is okay */
1733                 else if( strpbrk( acomment, "()" ) )
1734                     tty_printf(_("Invalid character in comment\n"));
1735                 else
1736                     break;
1737             }
1738         }
1739
1740
1741         m_free(uid);
1742         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1743         p = stpcpy(p, aname );
1744         if( *acomment )
1745             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1746         if( *amail )
1747             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1748
1749         /* append a warning if we do not have dev/random
1750          * or it is switched into  quick testmode */
1751         if( quick_random_gen(-1) )
1752             strcpy(p, " (INSECURE!)" );
1753
1754         /* print a note in case that UTF8 mapping has to be done */
1755         for(p=uid; *p; p++ ) {
1756             if( *p & 0x80 ) {
1757                 tty_printf(_("You are using the `%s' character set.\n"),
1758                            get_native_charset() );
1759                 break;
1760             }
1761         }
1762
1763         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1764         /* fixme: add a warning if this user-id already exists */
1765         if( !*amail && !opt.allow_freeform_uid
1766             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1767             fail = 1;
1768             tty_printf(_("Please don't put the email address "
1769                           "into the real name or the comment\n") );
1770         }
1771
1772         for(;;) {
1773             /* TRANSLATORS: These are the allowed answers in
1774                lower and uppercase.  Below you will find the matching
1775                string which should be translated accordingly and the
1776                letter changed to match the one in the answer string.
1777                
1778                  n = Change name
1779                  c = Change comment
1780                  e = Change email
1781                  o = Okay (ready, continue)
1782                  q = Quit
1783              */
1784             const char *ansstr = _("NnCcEeOoQq");
1785
1786             if( strlen(ansstr) != 10 )
1787                 BUG();
1788             if( cpr_enabled() ) {
1789                 answer = m_strdup(ansstr+6);
1790                 answer[1] = 0;
1791             }
1792             else {
1793                 answer = cpr_get("keygen.userid.cmd", fail?
1794                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1795                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1796                 cpr_kill_prompt();
1797             }
1798             if( strlen(answer) > 1 )
1799                 ;
1800             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1801                 m_free(aname); aname = NULL;
1802                 break;
1803             }
1804             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1805                 m_free(acomment); acomment = NULL;
1806                 break;
1807             }
1808             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1809                 m_free(amail); amail = NULL;
1810                 break;
1811             }
1812             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1813                 if( fail ) {
1814                     tty_printf(_("Please correct the error first\n"));
1815                 }
1816                 else {
1817                     m_free(aname); aname = NULL;
1818                     m_free(acomment); acomment = NULL;
1819                     m_free(amail); amail = NULL;
1820                     break;
1821                 }
1822             }
1823             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1824                 m_free(aname); aname = NULL;
1825                 m_free(acomment); acomment = NULL;
1826                 m_free(amail); amail = NULL;
1827                 m_free(uid); uid = NULL;
1828                 break;
1829             }
1830             m_free(answer);
1831         }
1832         m_free(answer);
1833         if( !amail && !acomment && !amail )
1834             break;
1835         m_free(uid); uid = NULL;
1836     }
1837     if( uid ) {
1838         char *p = native_to_utf8( uid );
1839         m_free( uid );
1840         uid = p;
1841     }
1842     return uid;
1843 }
1844
1845
1846 /* FIXME: We need a way to cancel this prompt. */
1847 static DEK *
1848 do_ask_passphrase( STRING2KEY **ret_s2k )
1849 {
1850     DEK *dek = NULL;
1851     STRING2KEY *s2k;
1852     const char *errtext = NULL;
1853
1854     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1855
1856     s2k = m_alloc_secure( sizeof *s2k );
1857     for(;;) {
1858         s2k->mode = opt.s2k_mode;
1859         s2k->hash_algo = S2K_DIGEST_ALGO;
1860         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1861                                  errtext, NULL);
1862         if( !dek ) {
1863             errtext = N_("passphrase not correctly repeated; try again");
1864             tty_printf(_("%s.\n"), _(errtext));
1865         }
1866         else if( !dek->keylen ) {
1867             m_free(dek); dek = NULL;
1868             m_free(s2k); s2k = NULL;
1869             tty_printf(_(
1870             "You don't want a passphrase - this is probably a *bad* idea!\n"
1871             "I will do it anyway.  You can change your passphrase at any time,\n"
1872             "using this program with the option \"--edit-key\".\n\n"));
1873             break;
1874         }
1875         else
1876             break; /* okay */
1877     }
1878     *ret_s2k = s2k;
1879     return dek;
1880 }
1881
1882
1883 static int
1884 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1885            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
1886            int is_subkey )
1887 {
1888   int rc=0;
1889
1890   if( !opt.batch )
1891     tty_printf(_(
1892 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1893 "some other action (type on the keyboard, move the mouse, utilize the\n"
1894 "disks) during the prime generation; this gives the random number\n"
1895 "generator a better chance to gain enough entropy.\n") );
1896
1897   if( algo == PUBKEY_ALGO_ELGAMAL_E )
1898     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1899                  is_subkey);
1900   else if( algo == PUBKEY_ALGO_DSA )
1901     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1902                  is_subkey);
1903   else if( algo == PUBKEY_ALGO_RSA )
1904     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1905                  is_subkey);
1906   else
1907     BUG();
1908
1909   return rc;
1910 }
1911
1912
1913 /****************
1914  * Generate a new user id packet, or return NULL if canceled
1915  */
1916 PKT_user_id *
1917 generate_user_id()
1918 {
1919     PKT_user_id *uid;
1920     char *p;
1921     size_t n;
1922
1923     p = ask_user_id( 1 );
1924     if( !p )
1925         return NULL;
1926     n = strlen(p);
1927     uid = m_alloc_clear( sizeof *uid + n - 1 );
1928     uid->len = n;
1929     strcpy(uid->name, p);
1930     uid->ref = 1;
1931     return uid;
1932 }
1933
1934
1935 static void
1936 release_parameter_list( struct para_data_s *r )
1937 {
1938     struct para_data_s *r2;
1939
1940     for( ; r ; r = r2 ) {
1941         r2 = r->next;
1942         if( r->key == pPASSPHRASE_DEK )
1943             m_free( r->u.dek );
1944         else if( r->key == pPASSPHRASE_S2K )
1945             m_free( r->u.s2k );
1946
1947         m_free(r);
1948     }
1949 }
1950
1951 static struct para_data_s *
1952 get_parameter( struct para_data_s *para, enum para_name key )
1953 {
1954     struct para_data_s *r;
1955
1956     for( r = para; r && r->key != key; r = r->next )
1957         ;
1958     return r;
1959 }
1960
1961 static const char *
1962 get_parameter_value( struct para_data_s *para, enum para_name key )
1963 {
1964     struct para_data_s *r = get_parameter( para, key );
1965     return (r && *r->u.value)? r->u.value : NULL;
1966 }
1967
1968 static int
1969 get_parameter_algo( struct para_data_s *para, enum para_name key )
1970 {
1971     int i;
1972     struct para_data_s *r = get_parameter( para, key );
1973     if( !r )
1974         return -1;
1975     if( digitp( r->u.value ) )
1976         i = atoi( r->u.value );
1977     else
1978         i = string_to_pubkey_algo( r->u.value );
1979     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1980       i = 0; /* we don't want to allow generation of these algorithms */
1981     return i;
1982 }
1983
1984 /* 
1985  * parse the usage parameter and set the keyflags.  Return true on error.
1986  */
1987 static int
1988 parse_parameter_usage (const char *fname,
1989                        struct para_data_s *para, enum para_name key)
1990 {
1991     struct para_data_s *r = get_parameter( para, key );
1992     char *p, *pn;
1993     unsigned int use;
1994
1995     if( !r )
1996         return 0; /* none (this is an optional parameter)*/
1997     
1998     use = 0;
1999     pn = r->u.value;
2000     while ( (p = strsep (&pn, " \t,")) ) {
2001         if ( !*p)
2002             ;
2003         else if ( !ascii_strcasecmp (p, "sign") )
2004             use |= PUBKEY_USAGE_SIG;
2005         else if ( !ascii_strcasecmp (p, "encrypt") )
2006             use |= PUBKEY_USAGE_ENC;
2007         else if ( !ascii_strcasecmp (p, "auth") )
2008             use |= PUBKEY_USAGE_AUTH;
2009         else {
2010             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2011             return -1; /* error */
2012         }
2013     }
2014     r->u.usage = use;
2015     return 0;
2016 }
2017
2018 static int
2019 parse_revocation_key (const char *fname,
2020                       struct para_data_s *para, enum para_name key)
2021 {
2022   struct para_data_s *r = get_parameter( para, key );
2023   struct revocation_key revkey;
2024   char *pn;
2025   int i;
2026
2027   if( !r )
2028     return 0; /* none (this is an optional parameter) */
2029
2030   pn = r->u.value;
2031
2032   revkey.class=0x80;
2033   revkey.algid=atoi(pn);
2034   if(!revkey.algid)
2035     goto fail;
2036
2037   /* Skip to the fpr */
2038   while(*pn && *pn!=':')
2039     pn++;
2040
2041   if(*pn!=':')
2042     goto fail;
2043
2044   pn++;
2045
2046   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2047     {
2048       int c=hextobyte(pn);
2049       if(c==-1)
2050         goto fail;
2051
2052       revkey.fpr[i]=c;
2053     }
2054
2055   /* skip to the tag */
2056   while(*pn && *pn!='s' && *pn!='S')
2057     pn++;
2058
2059   if(ascii_strcasecmp(pn,"sensitive")==0)
2060     revkey.class|=0x40;
2061
2062   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2063
2064   return 0;
2065
2066   fail:
2067   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2068   return -1; /* error */
2069 }
2070
2071
2072 static u32
2073 get_parameter_u32( struct para_data_s *para, enum para_name key )
2074 {
2075     struct para_data_s *r = get_parameter( para, key );
2076
2077     if( !r )
2078         return 0;
2079     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2080         return r->u.expire;
2081     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2082         return r->u.usage;
2083
2084     return (unsigned int)strtoul( r->u.value, NULL, 10 );
2085 }
2086
2087 static unsigned int
2088 get_parameter_uint( struct para_data_s *para, enum para_name key )
2089 {
2090     return get_parameter_u32( para, key );
2091 }
2092
2093 static DEK *
2094 get_parameter_dek( struct para_data_s *para, enum para_name key )
2095 {
2096     struct para_data_s *r = get_parameter( para, key );
2097     return r? r->u.dek : NULL;
2098 }
2099
2100 static STRING2KEY *
2101 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2102 {
2103     struct para_data_s *r = get_parameter( para, key );
2104     return r? r->u.s2k : NULL;
2105 }
2106
2107 static struct revocation_key *
2108 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2109 {
2110     struct para_data_s *r = get_parameter( para, key );
2111     return r? &r->u.revkey : NULL;
2112 }
2113
2114 static int
2115 proc_parameter_file( struct para_data_s *para, const char *fname,
2116                      struct output_control_s *outctrl, int card )
2117 {
2118     struct para_data_s *r;
2119     const char *s1, *s2, *s3;
2120     size_t n;
2121     char *p;
2122     int i;
2123
2124     /* Check that we have all required parameters. */
2125     assert( get_parameter( para, pKEYTYPE ) );
2126     i = get_parameter_algo( para, pKEYTYPE );
2127     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
2128         r = get_parameter( para, pKEYTYPE );
2129         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2130         return -1;
2131     }
2132
2133     if (parse_parameter_usage (fname, para, pKEYUSAGE))
2134         return -1;
2135
2136     i = get_parameter_algo( para, pSUBKEYTYPE );
2137     if( i > 0 && check_pubkey_algo( i ) ) {
2138         r = get_parameter( para, pSUBKEYTYPE );
2139         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2140         return -1;
2141     }
2142     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
2143         return -1;
2144
2145
2146     if( !get_parameter_value( para, pUSERID ) ) {
2147         /* create the formatted user ID */
2148         s1 = get_parameter_value( para, pNAMEREAL );
2149         s2 = get_parameter_value( para, pNAMECOMMENT );
2150         s3 = get_parameter_value( para, pNAMEEMAIL );
2151         if( s1 || s2 || s3 ) {
2152             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2153             r = m_alloc_clear( sizeof *r + n + 20 );
2154             r->key = pUSERID;
2155             p = r->u.value;
2156             if( s1 )
2157                 p = stpcpy(p, s1 );
2158             if( s2 )
2159                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2160             if( s3 )
2161                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2162             r->next = para;
2163             para = r;
2164         }
2165     }
2166
2167     /* Set preferences, if any. */
2168     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2169
2170     /* Set revoker, if any. */
2171     if (parse_revocation_key (fname, para, pREVOKER))
2172       return -1;
2173
2174     /* make DEK and S2K from the Passphrase */
2175     r = get_parameter( para, pPASSPHRASE );
2176     if( r && *r->u.value ) {
2177         /* we have a plain text passphrase - create a DEK from it.
2178          * It is a little bit ridiculous to keep it ih secure memory
2179          * but becuase we do this alwasy, why not here */
2180         STRING2KEY *s2k;
2181         DEK *dek;
2182
2183         s2k = m_alloc_secure( sizeof *s2k );
2184         s2k->mode = opt.s2k_mode;
2185         s2k->hash_algo = S2K_DIGEST_ALGO;
2186         set_next_passphrase( r->u.value );
2187         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2188                                  NULL, NULL);
2189         set_next_passphrase( NULL );
2190         assert( dek );
2191         memset( r->u.value, 0, strlen(r->u.value) );
2192
2193         r = m_alloc_clear( sizeof *r );
2194         r->key = pPASSPHRASE_S2K;
2195         r->u.s2k = s2k;
2196         r->next = para;
2197         para = r;
2198         r = m_alloc_clear( sizeof *r );
2199         r->key = pPASSPHRASE_DEK;
2200         r->u.dek = dek;
2201         r->next = para;
2202         para = r;
2203     }
2204
2205     /* make KEYEXPIRE from Expire-Date */
2206     r = get_parameter( para, pEXPIREDATE );
2207     if( r && *r->u.value )
2208       {
2209         u32 seconds;
2210
2211         seconds = parse_expire_string( r->u.value );
2212         if( seconds == (u32)-1 )
2213           {
2214             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2215             return -1;
2216           }
2217         r->u.expire = seconds;
2218         r->key = pKEYEXPIRE;  /* change hat entry */
2219         /* also set it for the subkey */
2220         r = m_alloc_clear( sizeof *r + 20 );
2221         r->key = pSUBKEYEXPIRE;
2222         r->u.expire = seconds;
2223         r->next = para;
2224         para = r;
2225       }
2226
2227     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2228         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2229         return -1;
2230     }
2231
2232     do_generate_keypair( para, outctrl, card );
2233     return 0;
2234 }
2235
2236
2237 /****************
2238  * Kludge to allow non interactive key generation controlled
2239  * by a parameter file.
2240  * Note, that string parameters are expected to be in UTF-8
2241  */
2242 static void
2243 read_parameter_file( const char *fname )
2244 {
2245     static struct { const char *name;
2246                     enum para_name key;
2247     } keywords[] = {
2248         { "Key-Type",       pKEYTYPE},
2249         { "Key-Length",     pKEYLENGTH },
2250         { "Key-Usage",      pKEYUSAGE },
2251         { "Subkey-Type",    pSUBKEYTYPE },
2252         { "Subkey-Length",  pSUBKEYLENGTH },
2253         { "Subkey-Usage",   pSUBKEYUSAGE },
2254         { "Name-Real",      pNAMEREAL },
2255         { "Name-Email",     pNAMEEMAIL },
2256         { "Name-Comment",   pNAMECOMMENT },
2257         { "Expire-Date",    pEXPIREDATE },
2258         { "Passphrase",     pPASSPHRASE },
2259         { "Preferences",    pPREFERENCES },
2260         { "Revoker",        pREVOKER },
2261         { "Handle",         pHANDLE },
2262         { NULL, 0 }
2263     };
2264     IOBUF fp;
2265     byte *line;
2266     unsigned int maxlen, nline;
2267     char *p;
2268     int lnr;
2269     const char *err = NULL;
2270     struct para_data_s *para, *r;
2271     int i;
2272     struct output_control_s outctrl;
2273
2274     memset( &outctrl, 0, sizeof( outctrl ) );
2275
2276     if( !fname || !*fname)
2277       fname = "-";
2278
2279     fp = iobuf_open (fname);
2280     if (fp && is_secured_file (iobuf_get_fd (fp)))
2281       {
2282         iobuf_close (fp);
2283         fp = NULL;
2284         errno = EPERM;
2285       }
2286     if (!fp) {
2287       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2288       return;
2289     }
2290     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2291
2292     lnr = 0;
2293     err = NULL;
2294     para = NULL;
2295     maxlen = 1024;
2296     line = NULL;
2297     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2298         char *keyword, *value;
2299
2300         lnr++;
2301         if( !maxlen ) {
2302             err = "line too long";
2303             break;
2304         }
2305         for( p = line; isspace(*(byte*)p); p++ )
2306             ;
2307         if( !*p || *p == '#' )
2308             continue;
2309         keyword = p;
2310         if( *keyword == '%' ) {
2311             for( ; !isspace(*(byte*)p); p++ )
2312                 ;
2313             if( *p )
2314                 *p++ = 0;
2315             for( ; isspace(*(byte*)p); p++ )
2316                 ;
2317             value = p;
2318             trim_trailing_ws( value, strlen(value) );
2319             if( !ascii_strcasecmp( keyword, "%echo" ) )
2320                 log_info("%s\n", value );
2321             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2322                 outctrl.dryrun = 1;
2323             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2324                 outctrl.lnr = lnr;
2325                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2326                   print_status_key_not_created 
2327                     (get_parameter_value (para, pHANDLE));
2328                 release_parameter_list( para );
2329                 para = NULL;
2330             }
2331             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2332                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2333                     ; /* still the same file - ignore it */
2334                 else {
2335                     m_free( outctrl.pub.newfname );
2336                     outctrl.pub.newfname = m_strdup( value );
2337                     outctrl.use_files = 1;
2338                 }
2339             }
2340             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2341                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2342                     ; /* still the same file - ignore it */
2343                 else {
2344                    m_free( outctrl.sec.newfname );
2345                    outctrl.sec.newfname = m_strdup( value );
2346                    outctrl.use_files = 1;
2347                 }
2348             }
2349             else
2350                 log_info("skipping control `%s' (%s)\n", keyword, value );
2351
2352
2353             continue;
2354         }
2355
2356
2357         if( !(p = strchr( p, ':' )) || p == keyword ) {
2358             err = "missing colon";
2359             break;
2360         }
2361         if( *p )
2362             *p++ = 0;
2363         for( ; isspace(*(byte*)p); p++ )
2364             ;
2365         if( !*p ) {
2366             err = "missing argument";
2367             break;
2368         }
2369         value = p;
2370         trim_trailing_ws( value, strlen(value) );
2371
2372         for(i=0; keywords[i].name; i++ ) {
2373             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2374                 break;
2375         }
2376         if( !keywords[i].name ) {
2377             err = "unknown keyword";
2378             break;
2379         }
2380         if( keywords[i].key != pKEYTYPE && !para ) {
2381             err = "parameter block does not start with \"Key-Type\"";
2382             break;
2383         }
2384
2385         if( keywords[i].key == pKEYTYPE && para ) {
2386             outctrl.lnr = lnr;
2387             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2388               print_status_key_not_created
2389                 (get_parameter_value (para, pHANDLE));
2390             release_parameter_list( para );
2391             para = NULL;
2392         }
2393         else {
2394             for( r = para; r; r = r->next ) {
2395                 if( r->key == keywords[i].key )
2396                     break;
2397             }
2398             if( r ) {
2399                 err = "duplicate keyword";
2400                 break;
2401             }
2402         }
2403         r = m_alloc_clear( sizeof *r + strlen( value ) );
2404         r->lnr = lnr;
2405         r->key = keywords[i].key;
2406         strcpy( r->u.value, value );
2407         r->next = para;
2408         para = r;
2409     }
2410     if( err )
2411         log_error("%s:%d: %s\n", fname, lnr, err );
2412     else if( iobuf_error (fp) ) {
2413         log_error("%s:%d: read error\n", fname, lnr);
2414     }
2415     else if( para ) {
2416         outctrl.lnr = lnr;
2417         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2418           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2419     }
2420
2421     if( outctrl.use_files ) { /* close open streams */
2422         iobuf_close( outctrl.pub.stream );
2423         iobuf_close( outctrl.sec.stream );
2424
2425         /* Must invalidate that ugly cache to actually close it.  */
2426         if (outctrl.pub.fname)
2427           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2428         if (outctrl.sec.fname)
2429           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2430
2431         m_free( outctrl.pub.fname );
2432         m_free( outctrl.pub.newfname );
2433         m_free( outctrl.sec.fname );
2434         m_free( outctrl.sec.newfname );
2435     }
2436
2437     release_parameter_list( para );
2438     iobuf_close (fp);
2439 }
2440
2441
2442 /*
2443  * Generate a keypair (fname is only used in batch mode) If
2444  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2445  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2446  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2447  * generate in software, imported to the card and a backup file
2448  * written to directory given by this argument .
2449  */
2450 void
2451 generate_keypair (const char *fname, const char *card_serialno, 
2452                   const char *backup_encryption_dir)
2453 {
2454   unsigned int nbits;
2455   char *uid = NULL;
2456   DEK *dek;
2457   STRING2KEY *s2k;
2458   int algo;
2459   unsigned int use;
2460   int both = 0;
2461   u32 expire;
2462   struct para_data_s *para = NULL;
2463   struct para_data_s *r;
2464   struct output_control_s outctrl;
2465   
2466   memset( &outctrl, 0, sizeof( outctrl ) );
2467   
2468   if (opt.batch && card_serialno)
2469     {
2470       /* We don't yet support unattended key generation. */
2471       log_error (_("can't do this in batch mode\n"));
2472       return;
2473     }
2474   
2475   if (opt.batch)
2476     {
2477       read_parameter_file( fname );
2478       return;
2479     }
2480
2481   if (card_serialno)
2482     {
2483 #ifdef ENABLE_CARD_SUPPORT
2484       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2485       r->key = pSERIALNO;
2486       strcpy( r->u.value, card_serialno);
2487       r->next = para;
2488       para = r;
2489        
2490       algo = PUBKEY_ALGO_RSA;
2491        
2492       r = xcalloc (1, sizeof *r + 20 );
2493       r->key = pKEYTYPE;
2494       sprintf( r->u.value, "%d", algo );
2495       r->next = para;
2496       para = r;
2497       r = xcalloc (1, sizeof *r + 20 );
2498       r->key = pKEYUSAGE;
2499       strcpy (r->u.value, "sign");
2500       r->next = para;
2501       para = r;
2502        
2503       r = xcalloc (1, sizeof *r + 20 );
2504       r->key = pSUBKEYTYPE;
2505       sprintf( r->u.value, "%d", algo );
2506       r->next = para;
2507       para = r;
2508       r = xcalloc (1, sizeof *r + 20 );
2509       r->key = pSUBKEYUSAGE;
2510       strcpy (r->u.value, "encrypt");
2511       r->next = para;
2512       para = r;
2513        
2514       r = xcalloc (1, sizeof *r + 20 );
2515       r->key = pAUTHKEYTYPE;
2516       sprintf( r->u.value, "%d", algo );
2517       r->next = para;
2518       para = r;
2519
2520       if (backup_encryption_dir)
2521         {
2522           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2523           r->key = pBACKUPENCDIR;
2524           strcpy (r->u.value, backup_encryption_dir);
2525           r->next = para;
2526           para = r;
2527         }
2528 #endif /*ENABLE_CARD_SUPPORT*/
2529     }
2530   else
2531     {
2532       algo = ask_algo( 0, &use );
2533       if( !algo )
2534         { /* default: DSA with ElG subkey of the specified size */
2535           both = 1;
2536           r = m_alloc_clear( sizeof *r + 20 );
2537           r->key = pKEYTYPE;
2538           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2539           r->next = para;
2540           para = r;
2541           tty_printf(_("DSA keypair will have %u bits.\n"),1024);
2542           r = m_alloc_clear( sizeof *r + 20 );
2543           r->key = pKEYLENGTH;
2544           strcpy( r->u.value, "1024" );
2545           r->next = para;
2546           para = r;
2547           r = m_alloc_clear( sizeof *r + 20 );
2548           r->key = pKEYUSAGE;
2549           strcpy( r->u.value, "sign" );
2550           r->next = para;
2551           para = r;
2552            
2553           algo = PUBKEY_ALGO_ELGAMAL_E;
2554           r = m_alloc_clear( sizeof *r + 20 );
2555           r->key = pSUBKEYTYPE;
2556           sprintf( r->u.value, "%d", algo );
2557           r->next = para;
2558           para = r;
2559           r = m_alloc_clear( sizeof *r + 20 );
2560           r->key = pSUBKEYUSAGE;
2561           strcpy( r->u.value, "encrypt" );
2562           r->next = para;
2563           para = r;
2564         }
2565       else 
2566         {
2567           r = m_alloc_clear( sizeof *r + 20 );
2568           r->key = pKEYTYPE;
2569           sprintf( r->u.value, "%d", algo );
2570           r->next = para;
2571           para = r;
2572            
2573           if (use)
2574             {
2575               r = m_alloc_clear( sizeof *r + 25 );
2576               r->key = pKEYUSAGE;
2577               sprintf( r->u.value, "%s%s%s",
2578                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2579                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
2580                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
2581               r->next = para;
2582               para = r;
2583             }
2584            
2585         }
2586        
2587       nbits = ask_keysize( algo );
2588       r = m_alloc_clear( sizeof *r + 20 );
2589       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2590       sprintf( r->u.value, "%u", nbits);
2591       r->next = para;
2592       para = r;
2593     }
2594    
2595   expire = ask_expire_interval(0,NULL);
2596   r = m_alloc_clear( sizeof *r + 20 );
2597   r->key = pKEYEXPIRE;
2598   r->u.expire = expire;
2599   r->next = para;
2600   para = r;
2601   r = m_alloc_clear( sizeof *r + 20 );
2602   r->key = pSUBKEYEXPIRE;
2603   r->u.expire = expire;
2604   r->next = para;
2605   para = r;
2606
2607   uid = ask_user_id(0);
2608   if( !uid ) 
2609     {
2610       log_error(_("Key generation canceled.\n"));
2611       release_parameter_list( para );
2612       return;
2613     }
2614   r = m_alloc_clear( sizeof *r + strlen(uid) );
2615   r->key = pUSERID;
2616   strcpy( r->u.value, uid );
2617   r->next = para;
2618   para = r;
2619     
2620   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2621   if( dek )
2622     {
2623       r = m_alloc_clear( sizeof *r );
2624       r->key = pPASSPHRASE_DEK;
2625       r->u.dek = dek;
2626       r->next = para;
2627       para = r;
2628       r = m_alloc_clear( sizeof *r );
2629       r->key = pPASSPHRASE_S2K;
2630       r->u.s2k = s2k;
2631       r->next = para;
2632       para = r;
2633     }
2634     
2635   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2636   release_parameter_list( para );
2637 }
2638
2639
2640 #ifdef ENABLE_CARD_SUPPORT
2641 /* Generate a raw key and return it as a secret key packet.  The
2642    function will ask for the passphrase and return a protected as well
2643    as an unprotected copy of a new secret key packet.  0 is returned
2644    on success and the caller must then free the returned values.  */
2645 static int
2646 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
2647                   PKT_secret_key **r_sk_unprotected,
2648                   PKT_secret_key **r_sk_protected)
2649 {
2650   int rc;
2651   DEK *dek = NULL;
2652   STRING2KEY *s2k = NULL;
2653   PKT_secret_key *sk = NULL;
2654   int i;
2655   size_t nskey, npkey;
2656
2657   npkey = pubkey_get_npkey (algo);
2658   nskey = pubkey_get_nskey (algo);
2659   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
2660
2661   if (nbits < 512)
2662     {
2663       nbits = 512;
2664       log_info (_("keysize invalid; using %u bits\n"), nbits );
2665     }
2666
2667   if ((nbits % 32)) 
2668     {
2669       nbits = ((nbits + 31) / 32) * 32;
2670       log_info(_("keysize rounded up to %u bits\n"), nbits );
2671     }
2672
2673   dek = do_ask_passphrase (&s2k);
2674
2675   sk = m_alloc_clear (sizeof *sk);
2676   sk->timestamp = created_at;
2677   sk->version = 4;
2678   sk->pubkey_algo = algo;
2679
2680   rc = pubkey_generate (algo, nbits, sk->skey, NULL);
2681   if (rc)
2682     {
2683       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
2684       goto leave;
2685     }
2686
2687   for (i=npkey; i < nskey; i++)
2688     sk->csum += checksum_mpi (sk->skey[i]);
2689
2690   if (r_sk_unprotected) 
2691     *r_sk_unprotected = copy_secret_key (NULL, sk);
2692
2693   if (dek)
2694     {
2695       sk->protect.algo = dek->algo;
2696       sk->protect.s2k = *s2k;
2697       rc = protect_secret_key (sk, dek);
2698       if (rc)
2699         {
2700           log_error ("protect_secret_key failed: %s\n", g10_errstr(rc));
2701           goto leave;
2702         }
2703     }
2704   if (r_sk_protected)
2705     {
2706       *r_sk_protected = sk;
2707       sk = NULL;
2708     }
2709
2710  leave:
2711   if (sk)
2712     free_secret_key (sk);
2713   m_free (dek);
2714   m_free (s2k);
2715   return rc;
2716 }
2717 #endif /* ENABLE_CARD_SUPPORT */
2718
2719 /* Create and delete a dummy packet to start off a list of kbnodes. */
2720 static void
2721 start_tree(KBNODE *tree)
2722 {
2723   PACKET *pkt;
2724
2725   pkt=m_alloc_clear(sizeof(*pkt));
2726   pkt->pkttype=PKT_NONE;
2727   *tree=new_kbnode(pkt);
2728   delete_kbnode(*tree);
2729 }
2730
2731 static void
2732 do_generate_keypair( struct para_data_s *para,
2733                      struct output_control_s *outctrl, int card )
2734 {
2735     KBNODE pub_root = NULL;
2736     KBNODE sec_root = NULL;
2737     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2738     const char *s;
2739     struct revocation_key *revkey;
2740     int rc;
2741     int did_sub = 0;
2742
2743     if( outctrl->dryrun )
2744       {
2745         log_info("dry-run mode - key generation skipped\n");
2746         return;
2747       }
2748
2749     if( outctrl->use_files ) {
2750         if( outctrl->pub.newfname ) {
2751             iobuf_close(outctrl->pub.stream);
2752             outctrl->pub.stream = NULL;
2753             if (outctrl->pub.fname)
2754               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
2755             m_free( outctrl->pub.fname );
2756             outctrl->pub.fname =  outctrl->pub.newfname;
2757             outctrl->pub.newfname = NULL;
2758
2759             if (is_secured_filename (outctrl->pub.fname) ) {
2760                 outctrl->pub.stream = NULL;
2761                 errno = EPERM;
2762             }
2763             else
2764                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2765             if( !outctrl->pub.stream ) {
2766                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
2767                                                      strerror(errno) );
2768                 return;
2769             }
2770             if( opt.armor ) {
2771                 outctrl->pub.afx.what = 1;
2772                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2773                                                     &outctrl->pub.afx );
2774             }
2775         }
2776         if( outctrl->sec.newfname ) {
2777             mode_t oldmask;
2778
2779             iobuf_close(outctrl->sec.stream);
2780             outctrl->sec.stream = NULL;
2781             if (outctrl->sec.fname)
2782               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
2783             m_free( outctrl->sec.fname );
2784             outctrl->sec.fname =  outctrl->sec.newfname;
2785             outctrl->sec.newfname = NULL;
2786
2787             oldmask = umask (077);
2788             if (is_secured_filename (outctrl->sec.fname) ) {
2789                 outctrl->sec.stream = NULL;
2790                 errno = EPERM;
2791             }
2792             else
2793                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2794             umask (oldmask);
2795             if( !outctrl->sec.stream ) {
2796                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
2797                                                      strerror(errno) );
2798                 return;
2799             }
2800             if( opt.armor ) {
2801                 outctrl->sec.afx.what = 5;
2802                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2803                                                     &outctrl->sec.afx );
2804             }
2805         }
2806         assert( outctrl->pub.stream );
2807         assert( outctrl->sec.stream );
2808         if( opt.verbose ) {
2809             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2810             if (card)
2811               log_info (_("writing secret key stub to `%s'\n"),
2812                         outctrl->sec.fname);
2813             else
2814               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2815         }
2816     }
2817
2818
2819     /* we create the packets as a tree of kbnodes. Because the
2820      * structure we create is known in advance we simply generate a
2821      * linked list.  The first packet is a dummy packet which we flag
2822      * as deleted.  The very first packet must always be a KEY packet.
2823      */
2824     
2825     start_tree(&pub_root);
2826     start_tree(&sec_root);
2827
2828     if (!card)
2829       {
2830         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2831                         get_parameter_uint( para, pKEYLENGTH ),
2832                         pub_root, sec_root,
2833                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2834                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2835                         &pri_sk,
2836                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
2837       }
2838     else
2839       {
2840         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root,
2841                            get_parameter_u32 (para, pKEYEXPIRE), para);
2842         if (!rc)
2843           {
2844             pri_sk = sec_root->next->pkt->pkt.secret_key;
2845             assert (pri_sk);
2846           }
2847       }
2848
2849     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2850       {
2851         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
2852         if(!rc)
2853           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
2854       }
2855
2856     if( !rc && (s=get_parameter_value(para, pUSERID)) )
2857       {
2858         write_uid(pub_root, s );
2859         if( !rc )
2860           write_uid(sec_root, s );
2861
2862         if( !rc )
2863           rc = write_selfsigs(sec_root, pub_root, pri_sk,
2864                               get_parameter_uint (para, pKEYUSAGE));
2865       }
2866
2867     /* Write the auth key to the card before the encryption key.  This
2868        is a partial workaround for a PGP bug (as of this writing, all
2869        versions including 8.1), that causes it to try and encrypt to
2870        the most recent subkey regardless of whether that subkey is
2871        actually an encryption type.  In this case, the auth key is an
2872        RSA key so it succeeds. */
2873
2874     if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
2875       {
2876         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root,
2877                            get_parameter_u32 (para, pKEYEXPIRE), para);
2878         
2879         if (!rc)
2880           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2881         if (!rc)
2882           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2883       }
2884
2885     if( !rc && get_parameter( para, pSUBKEYTYPE ) )
2886       {
2887         if (!card)
2888           {
2889             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2890                             get_parameter_uint( para, pSUBKEYLENGTH ),
2891                             pub_root, sec_root,
2892                             get_parameter_dek( para, pPASSPHRASE_DEK ),
2893                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
2894                             &sub_sk,
2895                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
2896           }
2897         else
2898           {
2899             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
2900               {
2901                 /* A backup of the encryption key has been requested.
2902                    Generate the key i software and import it then to
2903                    the card.  Write a backup file. */
2904                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
2905                                                pub_root, sec_root,
2906                                                get_parameter_u32 (para,
2907                                                                   pKEYEXPIRE),
2908                                                para, s);
2909               }
2910             else
2911               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
2912                                  get_parameter_u32 (para, pKEYEXPIRE), para);
2913           }
2914
2915         if( !rc )
2916           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
2917                                 get_parameter_uint (para, pSUBKEYUSAGE));
2918         if( !rc )
2919           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
2920                                 get_parameter_uint (para, pSUBKEYUSAGE));
2921         did_sub = 1;
2922       }
2923
2924     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2925         rc = write_keyblock( outctrl->pub.stream, pub_root );
2926         if( rc )
2927             log_error("can't write public key: %s\n", g10_errstr(rc) );
2928         if( !rc ) {
2929             rc = write_keyblock( outctrl->sec.stream, sec_root );
2930             if( rc )
2931                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2932         }
2933
2934     }
2935     else if( !rc ) { /* write to the standard keyrings */
2936         KEYDB_HANDLE pub_hd = keydb_new (0);
2937         KEYDB_HANDLE sec_hd = keydb_new (1);
2938
2939         /* FIXME: we may have to create the keyring first */
2940         rc = keydb_locate_writable (pub_hd, NULL);
2941         if (rc) 
2942             log_error (_("no writable public keyring found: %s\n"),
2943                        g10_errstr (rc));
2944
2945         if (!rc) {  
2946             rc = keydb_locate_writable (sec_hd, NULL);
2947             if (rc) 
2948                 log_error (_("no writable secret keyring found: %s\n"),
2949                            g10_errstr (rc));
2950         }
2951
2952         if (!rc && opt.verbose) {
2953             log_info(_("writing public key to `%s'\n"),
2954                      keydb_get_resource_name (pub_hd));
2955             if (card)
2956               log_info (_("writing secret key stub to `%s'\n"),
2957                         keydb_get_resource_name (sec_hd));
2958             else
2959               log_info(_("writing secret key to `%s'\n"),
2960                        keydb_get_resource_name (sec_hd));
2961         }
2962
2963         if (!rc) {
2964             rc = keydb_insert_keyblock (pub_hd, pub_root);
2965             if (rc)
2966                 log_error (_("error writing public keyring `%s': %s\n"),
2967                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2968         }
2969
2970         if (!rc) {
2971             rc = keydb_insert_keyblock (sec_hd, sec_root);
2972             if (rc)
2973                 log_error (_("error writing secret keyring `%s': %s\n"),
2974                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2975         }
2976
2977         keydb_release (pub_hd);
2978         keydb_release (sec_hd);
2979
2980         if (!rc) {
2981             int no_enc_rsa =
2982                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2983                 && get_parameter_uint( para, pKEYUSAGE )
2984                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2985             PKT_public_key *pk = find_kbnode (pub_root, 
2986                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2987
2988             keyid_from_pk(pk,pk->main_keyid);
2989             register_trusted_keyid(pk->main_keyid);
2990
2991             update_ownertrust (pk,
2992                                ((get_ownertrust (pk) & ~TRUST_MASK)
2993                                 | TRUST_ULTIMATE ));
2994
2995             if (!opt.batch) {
2996                 tty_printf(_("public and secret key created and signed.\n") );
2997                 tty_printf("\n");
2998                 list_keyblock(pub_root,0,1,NULL);
2999             }
3000             
3001
3002             if( !opt.batch
3003                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
3004                      || no_enc_rsa )
3005                 && !get_parameter( para, pSUBKEYTYPE ) )
3006             {
3007                 tty_printf(_("Note that this key cannot be used for "
3008                              "encryption.  You may want to use\n"
3009                              "the command \"--edit-key\" to generate a "
3010                              "subkey for this purpose.\n") );
3011             }
3012         }
3013     }
3014
3015     if( rc ) {
3016         if( opt.batch )
3017             log_error("key generation failed: %s\n", g10_errstr(rc) );
3018         else
3019             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
3020         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3021     }
3022     else {
3023         PKT_public_key *pk = find_kbnode (pub_root, 
3024                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3025         print_status_key_created (did_sub? 'B':'P', pk,
3026                                   get_parameter_value (para, pHANDLE));
3027     }
3028     release_kbnode( pub_root );
3029     release_kbnode( sec_root );
3030
3031     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
3032       free_secret_key(pri_sk); /* shallow copy in card mode. */
3033     if( sub_sk )
3034         free_secret_key(sub_sk);
3035 }
3036
3037
3038 /****************
3039  * add a new subkey to an existing key.
3040  * Returns true if a new key has been generated and put into the keyblocks.
3041  */
3042 int
3043 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
3044 {
3045     int okay=0, rc=0;
3046     KBNODE node;
3047     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3048     int algo;
3049     unsigned int use;
3050     u32 expire;
3051     unsigned nbits;
3052     char *passphrase = NULL;
3053     DEK *dek = NULL;
3054     STRING2KEY *s2k = NULL;
3055     u32 cur_time;
3056     int ask_pass = 0;
3057
3058     /* break out the primary secret key */
3059     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3060     if( !node ) {
3061         log_error("Oops; secret key not found anymore!\n");
3062         goto leave;
3063     }
3064
3065     /* make a copy of the sk to keep the protected one in the keyblock */
3066     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
3067
3068     cur_time = make_timestamp();
3069     if( pri_sk->timestamp > cur_time ) {
3070         ulong d = pri_sk->timestamp - cur_time;
3071         log_info( d==1 ? _("key has been created %lu second "
3072                            "in future (time warp or clock problem)\n")
3073                        : _("key has been created %lu seconds "
3074                            "in future (time warp or clock problem)\n"), d );
3075         if( !opt.ignore_time_conflict ) {
3076             rc = G10ERR_TIME_CONFLICT;
3077             goto leave;
3078         }
3079     }
3080
3081     if (pri_sk->version < 4) {
3082         log_info (_("NOTE: creating subkeys for v3 keys "
3083                     "is not OpenPGP compliant\n"));
3084         goto leave;
3085     }
3086
3087     if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) {
3088         tty_printf(_("Secret parts of primary key are not available.\n"));
3089         rc = G10ERR_NO_SECKEY;
3090         goto leave;
3091     }
3092
3093
3094     /* Unprotect to get the passphrase.  */
3095     switch( is_secret_key_protected( pri_sk ) ) {
3096       case -1:
3097         rc = G10ERR_PUBKEY_ALGO;
3098         break;
3099       case 0:
3100         tty_printf(_("This key is not protected.\n"));
3101         break;
3102       case -2:
3103         tty_printf(_("Secret parts of primary key are stored on-card.\n"));
3104         ask_pass = 1;
3105         break;
3106       default:
3107         tty_printf(_("Key is protected.\n"));
3108         rc = check_secret_key( pri_sk, 0 );
3109         if( !rc )
3110             passphrase = get_last_passphrase();
3111         break;
3112     }
3113     if( rc )
3114         goto leave;
3115
3116     algo = ask_algo( 1, &use );
3117     assert(algo);
3118     nbits = ask_keysize( algo );
3119     expire = ask_expire_interval(0,NULL);
3120     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3121                                                   _("Really create? (y/N) ")))
3122         goto leave;
3123
3124     if (ask_pass)
3125         dek = do_ask_passphrase (&s2k);
3126     else if (passphrase) {
3127         s2k = m_alloc_secure( sizeof *s2k );
3128         s2k->mode = opt.s2k_mode;
3129         s2k->hash_algo = S2K_DIGEST_ALGO;
3130         set_next_passphrase( passphrase );
3131         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3132                                  NULL, NULL );
3133     }
3134
3135     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
3136                                       dek, s2k, &sub_sk, expire, 1 );
3137     if( !rc )
3138         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3139     if( !rc )
3140         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3141     if( !rc ) {
3142         okay = 1;
3143         write_status_text (STATUS_KEY_CREATED, "S");
3144     }
3145
3146   leave:
3147     if( rc )
3148         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3149     m_free( passphrase );
3150     m_free( dek );
3151     m_free( s2k );
3152     /* release the copy of the (now unprotected) secret keys */
3153     if( pri_sk )
3154         free_secret_key(pri_sk);
3155     if( sub_sk )
3156         free_secret_key(sub_sk);
3157     set_next_passphrase( NULL );
3158     return okay;
3159 }
3160
3161
3162 #ifdef ENABLE_CARD_SUPPORT
3163 /* Generate a subkey on a card. */
3164 int
3165 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3166                           int keyno, const char *serialno)
3167 {
3168   int okay=0, rc=0;
3169   KBNODE node;
3170   PKT_secret_key *pri_sk = NULL;
3171   int algo;
3172   unsigned int use;
3173   u32 expire;
3174   char *passphrase = NULL;
3175   u32 cur_time;
3176   struct para_data_s *para = NULL;
3177
3178   assert (keyno >= 1 && keyno <= 3);
3179
3180   para = xcalloc (1, sizeof *para + strlen (serialno) );
3181   para->key = pSERIALNO;
3182   strcpy (para->u.value, serialno);
3183
3184   /* Break out the primary secret key */
3185   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3186   if(!node)
3187     {
3188       log_error("Oops; secret key not found anymore!\n");
3189       goto leave;
3190     }
3191
3192   /* Make a copy of the sk to keep the protected one in the keyblock */
3193   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3194
3195   cur_time = make_timestamp();
3196   if (pri_sk->timestamp > cur_time)
3197     {
3198       ulong d = pri_sk->timestamp - cur_time;
3199       log_info (d==1 ? _("key has been created %lu second "
3200                          "in future (time warp or clock problem)\n")
3201                      : _("key has been created %lu seconds "
3202                          "in future (time warp or clock problem)\n"), d );
3203         if (!opt.ignore_time_conflict)
3204           {
3205             rc = G10ERR_TIME_CONFLICT;
3206             goto leave;
3207           }
3208     }
3209
3210   if (pri_sk->version < 4)
3211     {
3212       log_info (_("NOTE: creating subkeys for v3 keys "
3213                   "is not OpenPGP compliant\n"));
3214       goto leave;
3215     }
3216
3217   /* Unprotect to get the passphrase. */
3218   switch( is_secret_key_protected (pri_sk) )
3219     {
3220     case -1:
3221       rc = G10ERR_PUBKEY_ALGO;
3222       break;
3223     case 0:
3224       tty_printf("This key is not protected.\n");
3225       break;
3226     default:
3227       tty_printf("Key is protected.\n");
3228       rc = check_secret_key( pri_sk, 0 );
3229       if (!rc)
3230         passphrase = get_last_passphrase();
3231       break;
3232     }
3233   if (rc)
3234     goto leave;
3235
3236   algo = PUBKEY_ALGO_RSA;
3237   expire = ask_expire_interval (0,NULL);
3238   if (keyno == 1)
3239     use = PUBKEY_USAGE_SIG;
3240   else if (keyno == 2)
3241     use = PUBKEY_USAGE_ENC;
3242   else
3243     use = PUBKEY_USAGE_AUTH;
3244   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3245                                                _("Really create? (y/N) ")))
3246     goto leave;
3247
3248   if (passphrase)
3249     set_next_passphrase (passphrase);
3250   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock, expire, para);
3251   if (!rc)
3252     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, NULL, use);
3253   if (!rc)
3254     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, NULL, use);
3255   if (!rc)
3256     {
3257       okay = 1;
3258       write_status_text (STATUS_KEY_CREATED, "S");
3259     }
3260
3261  leave:
3262   if (rc)
3263     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3264   m_free (passphrase);
3265   /* Release the copy of the (now unprotected) secret keys. */
3266   if (pri_sk)
3267     free_secret_key (pri_sk);
3268   set_next_passphrase( NULL );
3269   release_parameter_list (para);
3270   return okay;
3271 }
3272 #endif /* !ENABLE_CARD_SUPPORT */
3273
3274
3275 /****************
3276  * Write a keyblock to an output stream
3277  */
3278 static int
3279 write_keyblock( IOBUF out, KBNODE node )
3280 {
3281     for( ; node ; node = node->next ) {
3282         int rc = build_packet( out, node->pkt );
3283         if( rc ) {
3284             log_error("build_packet(%d) failed: %s\n",
3285                         node->pkt->pkttype, g10_errstr(rc) );
3286             return G10ERR_WRITE_FILE;
3287         }
3288     }
3289     return 0;
3290 }
3291
3292
3293 static int
3294 gen_card_key (int algo, int keyno, int is_primary,
3295               KBNODE pub_root, KBNODE sec_root,
3296               u32 expireval, struct para_data_s *para)
3297 {
3298 #ifdef ENABLE_CARD_SUPPORT
3299   int rc;
3300   const char *s;
3301   struct agent_card_genkey_s info;
3302   PACKET *pkt;
3303   PKT_secret_key *sk;
3304   PKT_public_key *pk;
3305
3306   assert (algo == PUBKEY_ALGO_RSA);
3307   
3308
3309   rc = agent_scd_genkey (&info, keyno, 1);
3310 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3311 /*      { */
3312 /*        tty_printf ("\n"); */
3313 /*        log_error ("WARNING: key does already exists!\n"); */
3314 /*        tty_printf ("\n"); */
3315 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3316 /*                                    _("Replace existing key? "))) */
3317 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3318 /*      } */
3319
3320   if (rc)
3321     {
3322       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3323       return rc;
3324     }
3325   if ( !info.n || !info.e )
3326     {
3327       log_error ("communication error with SCD\n");
3328       mpi_free (info.n);
3329       mpi_free (info.e);
3330       return gpg_error (GPG_ERR_GENERAL);
3331     }
3332   
3333
3334   pk = xcalloc (1, sizeof *pk );
3335   sk = xcalloc (1, sizeof *sk );
3336   sk->timestamp = pk->timestamp = info.created_at;
3337   sk->version = pk->version = 4;
3338   if (expireval)
3339       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3340   sk->pubkey_algo = pk->pubkey_algo = algo;
3341   pk->pkey[0] = info.n;
3342   pk->pkey[1] = info.e; 
3343   sk->skey[0] = mpi_copy (pk->pkey[0]);
3344   sk->skey[1] = mpi_copy (pk->pkey[1]);
3345   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3346   sk->is_protected = 1;
3347   sk->protect.s2k.mode = 1002;
3348   s = get_parameter_value (para, pSERIALNO);
3349   if (s)
3350     {
3351       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3352            sk->protect.ivlen++, s += 2)
3353         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3354     }
3355
3356   pkt = xcalloc (1,sizeof *pkt);
3357   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3358   pkt->pkt.public_key = pk;
3359   add_kbnode(pub_root, new_kbnode( pkt ));
3360
3361   pkt = xcalloc (1,sizeof *pkt);
3362   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3363   pkt->pkt.secret_key = sk;
3364   add_kbnode(sec_root, new_kbnode( pkt ));
3365
3366   return 0;
3367 #else
3368   return -1;
3369 #endif /*!ENABLE_CARD_SUPPORT*/
3370 }
3371
3372
3373
3374 static int
3375 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3376                           KBNODE pub_root, KBNODE sec_root,
3377                           u32 expireval, struct para_data_s *para,
3378                           const char *backup_dir)
3379 {
3380 #ifdef ENABLE_CARD_SUPPORT
3381   int rc;
3382   const char *s;
3383   PACKET *pkt;
3384   PKT_secret_key *sk, *sk_unprotected, *sk_protected;
3385   PKT_public_key *pk;
3386   size_t n;
3387   int i;
3388
3389   rc = generate_raw_key (algo, 1024, make_timestamp (),
3390                          &sk_unprotected, &sk_protected);
3391   if (rc)
3392     return rc;
3393
3394   /* First, store the key to the card. */
3395   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3396   if (rc)
3397     {
3398       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3399       free_secret_key (sk_unprotected);
3400       free_secret_key (sk_protected);
3401       return rc;
3402     }
3403
3404   /* Get rid of the secret key parameters and store the serial numer. */
3405   sk = sk_unprotected;
3406   n = pubkey_get_nskey (sk->pubkey_algo);
3407   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3408     {
3409       mpi_free (sk->skey[i]);
3410       sk->skey[i] = NULL;
3411     }
3412   i = pubkey_get_npkey (sk->pubkey_algo);
3413   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3414   sk->is_protected = 1;
3415   sk->protect.s2k.mode = 1002;
3416   s = get_parameter_value (para, pSERIALNO);
3417   assert (s);
3418   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3419        sk->protect.ivlen++, s += 2)
3420     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3421
3422   /* Now write the *protected* secret key to the file.  */
3423   {
3424     char name_buffer[50];
3425     char *fname;
3426     IOBUF fp;
3427     mode_t oldmask;
3428
3429     keyid_from_sk (sk, NULL);
3430     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
3431              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3432
3433     fname = make_filename (backup_dir, name_buffer, NULL);
3434     oldmask = umask (077);
3435     if (is_secured_filename (fname))
3436       {
3437         fp = NULL;
3438         errno = EPERM;
3439       }
3440     else
3441       fp = iobuf_create (fname);
3442     umask (oldmask);
3443     if (!fp) 
3444       {
3445         log_error (_("can't create backup file `%s': %s\n"),
3446                    fname, strerror(errno) );
3447         m_free (fname);
3448         free_secret_key (sk_unprotected);
3449         free_secret_key (sk_protected);
3450         return G10ERR_OPEN_FILE;
3451       }
3452
3453     pkt = xcalloc (1, sizeof *pkt);
3454     pkt->pkttype = PKT_SECRET_KEY;
3455     pkt->pkt.secret_key = sk_protected;
3456     sk_protected = NULL;
3457
3458     rc = build_packet (fp, pkt);
3459     if (rc)
3460       {
3461         log_error("build packet failed: %s\n", g10_errstr(rc) );
3462         iobuf_cancel (fp);
3463       }
3464     else
3465       {
3466         byte array[MAX_FINGERPRINT_LEN];
3467         char *fprbuf, *p;
3468        
3469         iobuf_close (fp);
3470         iobuf_ioctl (NULL, 2, 0, (char*)fname);
3471         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3472
3473         fingerprint_from_sk (sk, array, &n);
3474         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
3475         for (i=0; i < n ; i++, p += 2)
3476           sprintf (p, "%02X", array[i]);
3477         *p++ = ' ';
3478         *p = 0;
3479
3480         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
3481                                       fprbuf,
3482                                       fname, strlen (fname),
3483                                       0);
3484         xfree (fprbuf);
3485       }
3486     free_packet (pkt);
3487     m_free (pkt);
3488     m_free (fname);
3489     if (rc)
3490       {
3491         free_secret_key (sk_unprotected);
3492         return rc;
3493       }
3494   }
3495
3496   /* Create the public key from the secret key. */
3497   pk = xcalloc (1, sizeof *pk );
3498   pk->timestamp = sk->timestamp;
3499   pk->version = sk->version;
3500   if (expireval)
3501       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3502   pk->pubkey_algo = sk->pubkey_algo;
3503   n = pubkey_get_npkey (sk->pubkey_algo);
3504   for (i=0; i < n; i++)
3505     pk->pkey[i] = mpi_copy (sk->skey[i]);
3506
3507   /* Build packets and add them to the node lists.  */
3508   pkt = xcalloc (1,sizeof *pkt);
3509   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3510   pkt->pkt.public_key = pk;
3511   add_kbnode(pub_root, new_kbnode( pkt ));
3512
3513   pkt = xcalloc (1,sizeof *pkt);
3514   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3515   pkt->pkt.secret_key = sk;
3516   add_kbnode(sec_root, new_kbnode( pkt ));
3517
3518   return 0;
3519 #else
3520   return -1;
3521 #endif /*!ENABLE_CARD_SUPPORT*/
3522 }
3523
3524
3525 #ifdef ENABLE_CARD_SUPPORT
3526 int
3527 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3528 {
3529   int rc;
3530   size_t n;
3531   MPI rsa_n, rsa_e, rsa_p, rsa_q;
3532   unsigned int nbits;
3533   unsigned char *template = NULL;
3534   unsigned char *tp;
3535   unsigned char m[128], e[4];
3536   size_t mlen, elen;
3537
3538   assert (is_RSA (sk->pubkey_algo));
3539   assert (!sk->is_protected);
3540
3541   rc = -1;
3542   /* Some basic checks on the key parameters. */
3543   rsa_n = sk->skey[0];
3544   rsa_e = sk->skey[1];
3545   rsa_p = sk->skey[3];
3546   rsa_q = sk->skey[4];
3547
3548   nbits = GET_NBITS (rsa_n);
3549   if (nbits != 1024)
3550     {
3551       log_error (_("length of RSA modulus is not %d\n"), 1024);
3552       goto leave;
3553     }
3554   nbits = GET_NBITS (rsa_e);
3555   if (nbits < 2 || nbits > 32)
3556     {
3557       log_error (_("public exponent too large (more than 32 bits)\n"));
3558       goto leave;
3559     }
3560   nbits = GET_NBITS (rsa_p);
3561   if (nbits != 512)
3562     {
3563       log_error (_("length of an RSA prime is not %d\n"), 512);
3564       goto leave;
3565     }
3566   nbits = GET_NBITS (rsa_q);
3567   if (nbits != 512)
3568     {
3569       log_error (_("length of an RSA prime is not %d\n"), 512);
3570       goto leave;
3571     }
3572
3573   
3574   /* We need the modulus later to calculate the fingerprint. */
3575   rc = copy_mpi (rsa_n, m, 128, &n);
3576   if (rc)
3577     goto leave;
3578   assert (n == 128);
3579   mlen = 128;
3580
3581   /* Build the private key template as described in section 4.3.3.6 of
3582      the OpenPGP card specs:
3583          0xC0   <length> public exponent
3584          0xC1   <length> prime p 
3585          0xC2   <length> prime q 
3586   */
3587   template = tp = xmalloc_secure (1+2 + 1+1+4 + 1+1+(512/8) + 1+1+(512/8));
3588   *tp++ = 0xC0;
3589   *tp++ = 4;
3590   rc = copy_mpi (rsa_e, tp, 4, &n);
3591   if (rc)
3592     goto leave;
3593   assert (n <= 4);
3594   memcpy (e, tp, n);  /* Save a copy of the exponent for later use.  */
3595   elen = n;
3596   if (n != 4)
3597     {
3598       memmove (tp+4-n, tp, 4-n);
3599       memset (tp, 0, 4-n);
3600     }                 
3601   tp += 4;
3602
3603   *tp++ = 0xC1;
3604   *tp++ = 64;
3605   rc = copy_mpi (rsa_p, tp, 64, &n);
3606   if (rc)
3607     goto leave;
3608   assert (n == 64);
3609   tp += 64;
3610
3611   *tp++ = 0xC2;
3612   *tp++ = 64;
3613   rc = copy_mpi (rsa_q, tp, 64, &n);
3614   if (rc)
3615     goto leave;
3616   assert (n == 64);
3617   tp += 64;
3618   assert (tp - template == 138);
3619
3620   rc = agent_openpgp_storekey (keyno,
3621                                template, tp - template,
3622                                sk->timestamp,
3623                                m, mlen,
3624                                e, elen);
3625
3626  leave:
3627   xfree (template);
3628   return rc;
3629 }
3630 #endif /*ENABLE_CARD_SUPPORT*/