* options.h, g10.c (main): Add new --default-sig-expire and
[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. */
352             if(!check_cipher_algo(CIPHER_ALGO_AES256))
353               strcat(dummy_string,"S9 ");
354             if(!check_cipher_algo(CIPHER_ALGO_AES192))
355               strcat(dummy_string,"S8 ");
356             if(!check_cipher_algo(CIPHER_ALGO_AES))
357               strcat(dummy_string,"S7 ");
358             if(!check_cipher_algo(CIPHER_ALGO_CAST5))
359               strcat(dummy_string,"S3 ");
360             strcat(dummy_string,"S2 "); /* 3DES */
361             /* If we have it, IDEA goes *after* 3DES so it won't be
362                used unless we're encrypting along with a V3 key.
363                Ideally, we would only put the S1 preference in if the
364                key was RSA and <=2048 bits, as that is what won't
365                break PGP2, but that is difficult with the current
366                code, and not really worth checking as a non-RSA <=2048
367                bit key wouldn't be usable by PGP2 anyway. -dms */
368             if(!check_cipher_algo(CIPHER_ALGO_IDEA))
369               strcat(dummy_string,"S1 ");
370
371             /* SHA-1, RIPEMD160, ZLIB, ZIP */
372             strcat(dummy_string,"H2 H3 Z2 Z1");
373
374             string=dummy_string;
375           }
376       }
377     else if (!ascii_strcasecmp (string, "none"))
378         string = "";
379
380     if(strlen(string))
381       {
382         char *tok,*prefstring;
383
384         prefstring=m_strdup(string); /* need a writable string! */
385
386         while((tok=strsep(&prefstring," ,")))
387           {
388             if((val=string_to_cipher_algo(tok)))
389               {
390                 if(set_one_pref(val,1,tok,sym,&nsym))
391                   rc=-1;
392               }
393             else if((val=string_to_digest_algo(tok)))
394               {
395                 if(set_one_pref(val,2,tok,hash,&nhash))
396                   rc=-1;
397               }
398             else if((val=string_to_compress_algo(tok))>-1)
399               {
400                 if(set_one_pref(val,3,tok,zip,&nzip))
401                   rc=-1;
402               }
403             else if (ascii_strcasecmp(tok,"mdc")==0)
404               mdc=1;
405             else if (ascii_strcasecmp(tok,"no-mdc")==0)
406               mdc=0;
407             else if (ascii_strcasecmp(tok,"ks-modify")==0)
408               modify=1;
409             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
410               modify=0;
411             else
412               {
413                 log_info (_("invalid item `%s' in preference string\n"),tok);
414
415                 /* Complain if IDEA is not available. */
416                 if(ascii_strcasecmp(tok,"s1")==0
417                    || ascii_strcasecmp(tok,"idea")==0)
418                   idea_cipher_warn(1);
419
420                 rc=-1;
421               }
422           }
423
424         m_free(prefstring);
425       }
426
427     if(!rc)
428       {
429         if(personal)
430           {
431             if(personal==PREFTYPE_SYM)
432               {
433                 m_free(opt.personal_cipher_prefs);
434
435                 if(nsym==0)
436                   opt.personal_cipher_prefs=NULL;
437                 else
438                   {
439                     int i;
440
441                     opt.personal_cipher_prefs=
442                       m_alloc(sizeof(prefitem_t *)*(nsym+1));
443
444                     for (i=0; i<nsym; i++)
445                       {
446                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
447                         opt.personal_cipher_prefs[i].value = sym[i];
448                       }
449
450                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
451                     opt.personal_cipher_prefs[i].value = 0;
452                   }
453               }
454             else if(personal==PREFTYPE_HASH)
455               {
456                 m_free(opt.personal_digest_prefs);
457
458                 if(nhash==0)
459                   opt.personal_digest_prefs=NULL;
460                 else
461                   {
462                     int i;
463
464                     opt.personal_digest_prefs=
465                       m_alloc(sizeof(prefitem_t *)*(nhash+1));
466
467                     for (i=0; i<nhash; i++)
468                       {
469                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
470                         opt.personal_digest_prefs[i].value = hash[i];
471                       }
472
473                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
474                     opt.personal_digest_prefs[i].value = 0;
475                   }
476               }
477             else if(personal==PREFTYPE_ZIP)
478               {
479                 m_free(opt.personal_compress_prefs);
480
481                 if(nzip==0)
482                   opt.personal_compress_prefs=NULL;
483                 else
484                   {
485                     int i;
486
487                     opt.personal_compress_prefs=
488                       m_alloc(sizeof(prefitem_t *)*(nzip+1));
489
490                     for (i=0; i<nzip; i++)
491                       {
492                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
493                         opt.personal_compress_prefs[i].value = zip[i];
494                       }
495
496                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
497                     opt.personal_compress_prefs[i].value = 0;
498                   }
499               }
500           }
501         else
502           {
503             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
504             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
505             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
506             mdc_available = mdc;
507             ks_modify = modify;
508             prefs_initialized = 1;
509           }
510       }
511
512     return rc;
513 }
514
515 /* Return a fake user ID containing the preferences.  Caller must
516    free. */
517 PKT_user_id *keygen_get_std_prefs(void)
518 {
519   int i,j=0;
520   PKT_user_id *uid=m_alloc_clear(sizeof(PKT_user_id));
521
522   if(!prefs_initialized)
523     keygen_set_std_prefs(NULL,0);
524
525   uid->ref=1;
526
527   uid->prefs=m_alloc((sizeof(prefitem_t *)*
528                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
529
530   for(i=0;i<nsym_prefs;i++,j++)
531     {
532       uid->prefs[j].type=PREFTYPE_SYM;
533       uid->prefs[j].value=sym_prefs[i];
534     }
535
536   for(i=0;i<nhash_prefs;i++,j++)
537     {
538       uid->prefs[j].type=PREFTYPE_HASH;
539       uid->prefs[j].value=hash_prefs[i];
540     }
541
542   for(i=0;i<nzip_prefs;i++,j++)
543     {
544       uid->prefs[j].type=PREFTYPE_ZIP;
545       uid->prefs[j].value=zip_prefs[i];
546     }
547
548   uid->prefs[j].type=PREFTYPE_NONE;
549   uid->prefs[j].value=0;
550
551   uid->mdc_feature=mdc_available;
552   uid->ks_modify=ks_modify;
553
554   return uid;
555 }
556
557 static void
558 add_feature_mdc (PKT_signature *sig,int enabled)
559 {
560     const byte *s;
561     size_t n;
562     int i;
563     char *buf;
564
565     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
566     /* Already set or cleared */
567     if (s && n &&
568         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
569       return;
570
571     if (!s || !n) { /* create a new one */
572         n = 1;
573         buf = m_alloc_clear (n);
574     }
575     else {
576         buf = m_alloc (n);
577         memcpy (buf, s, n);
578     }
579
580     if(enabled)
581       buf[0] |= 0x01; /* MDC feature */
582     else
583       buf[0] &= ~0x01;
584
585     /* Are there any bits set? */
586     for(i=0;i<n;i++)
587       if(buf[i]!=0)
588         break;
589
590     if(i==n)
591       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
592     else
593       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
594
595     m_free (buf);
596 }
597
598 static void
599 add_keyserver_modify (PKT_signature *sig,int enabled)
600 {
601   const byte *s;
602   size_t n;
603   int i;
604   char *buf;
605
606   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
607   enabled=!enabled;
608
609   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
610   /* Already set or cleared */
611   if (s && n &&
612       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
613     return;
614
615   if (!s || !n) { /* create a new one */
616     n = 1;
617     buf = m_alloc_clear (n);
618   }
619   else {
620     buf = m_alloc (n);
621     memcpy (buf, s, n);
622   }
623
624   if(enabled)
625     buf[0] |= 0x80; /* no-modify flag */
626   else
627     buf[0] &= ~0x80;
628
629   /* Are there any bits set? */
630   for(i=0;i<n;i++)
631     if(buf[i]!=0)
632       break;
633
634   if(i==n)
635     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
636   else
637     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
638
639   m_free (buf);
640 }
641
642 int
643 keygen_upd_std_prefs( PKT_signature *sig, void *opaque )
644 {
645     if (!prefs_initialized)
646         keygen_set_std_prefs (NULL, 0);
647
648     if (nsym_prefs) 
649         build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
650     else
651       {
652         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
653         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
654       }
655
656     if (nhash_prefs)
657         build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
658     else
659       {
660         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
661         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
662       }
663
664     if (nzip_prefs)
665         build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
666     else
667       {
668         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
669         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
670       }
671
672     /* Make sure that the MDC feature flag is set if needed */
673     add_feature_mdc (sig,mdc_available);
674     add_keyserver_modify (sig,ks_modify);
675
676     return 0;
677 }
678
679
680 /****************
681  * Add preference to the self signature packet.
682  * This is only called for packets with version > 3.
683
684  */
685 int
686 keygen_add_std_prefs( PKT_signature *sig, void *opaque )
687 {
688     PKT_public_key *pk = opaque;
689
690     do_add_key_flags (sig, pk->pubkey_usage);
691     keygen_add_key_expire( sig, opaque );
692     keygen_upd_std_prefs (sig, opaque);
693
694     return 0;
695 }
696
697 int
698 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
699 {
700   const char *url=opaque;
701
702   if(url)
703     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
704   else
705     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
706
707   return 0;
708 }
709
710 int
711 keygen_add_revkey(PKT_signature *sig, void *opaque)
712 {
713   struct revocation_key *revkey=opaque;
714   byte buf[2+MAX_FINGERPRINT_LEN];
715
716   buf[0]=revkey->class;
717   buf[1]=revkey->algid;
718   memcpy(&buf[2],revkey->fpr,MAX_FINGERPRINT_LEN);
719
720   build_sig_subpkt(sig,SIGSUBPKT_REV_KEY,buf,2+MAX_FINGERPRINT_LEN);
721
722   /* All sigs with revocation keys set are nonrevocable */
723   sig->flags.revocable=0;
724   buf[0] = 0;
725   build_sig_subpkt( sig, SIGSUBPKT_REVOCABLE, buf, 1 );
726
727   parse_revkeys(sig);
728
729   return 0;
730 }
731
732 static int
733 make_backsig(PKT_signature *sig, PKT_public_key *pk,
734              PKT_public_key *sub_pk, PKT_secret_key *sub_sk)
735 {
736   PKT_signature *backsig;
737   int rc;
738
739 #ifndef DO_BACKSIGS
740   /* This is not enabled yet, as I want to get a bit closer to RFC day
741      before enabling this.  I've been burned before :) */
742
743   return 0;
744 #endif
745
746   cache_public_key (sub_pk);
747
748   rc=make_keysig_packet(&backsig,pk,NULL,sub_pk,sub_sk, 0x19, 0, 0, 0, 0,
749                         NULL,NULL);
750   if( rc )
751     log_error("make_keysig_packet failed for backsig: %s\n", g10_errstr(rc) );
752   else
753     {
754       /* get it into a binary packed form. */
755       IOBUF backsig_out=iobuf_temp();
756       PACKET backsig_pkt;
757  
758       init_packet(&backsig_pkt);
759       backsig_pkt.pkttype=PKT_SIGNATURE;
760       backsig_pkt.pkt.signature=backsig;
761       rc=build_packet(backsig_out,&backsig_pkt);
762       free_packet(&backsig_pkt);
763       if(rc)
764         log_error("build_packet failed for backsig: %s\n",g10_errstr(rc));
765       else
766         {
767           size_t pktlen=0;
768           byte *buf=iobuf_get_temp_buffer(backsig_out);
769  
770           /* Remove the packet header */
771           if(buf[0]&0x40)
772             {
773               if(buf[1]<192)
774                 {
775                   pktlen=buf[1];
776                   buf+=2;
777                 }
778               else if(buf[1]<224)
779                 {
780                   pktlen=(buf[1]-192)*256;
781                   pktlen+=buf[2]+192;
782                   buf+=3;
783                 }
784               else if(buf[1]==255)
785                 {
786                   pktlen =buf[2] << 24;
787                   pktlen|=buf[3] << 16;
788                   pktlen|=buf[4] << 8;
789                   pktlen|=buf[5];
790                   buf+=6;
791                 }
792               else
793                 BUG();
794             }
795           else
796             {
797               int mark=1;
798  
799               switch(buf[0]&3)
800                 {
801                 case 3:
802                   BUG();
803                   break;
804  
805                 case 2:
806                   pktlen =buf[mark++] << 24;
807                   pktlen|=buf[mark++] << 16;
808  
809                 case 1:
810                   pktlen|=buf[mark++] << 8;
811  
812                 case 0:
813                   pktlen|=buf[mark++];
814                 }
815  
816               buf+=mark;
817             }
818  
819           /* now make the binary blob into a subpacket */
820           build_sig_subpkt(sig,SIGSUBPKT_SIGNATURE,buf,pktlen);
821
822           iobuf_close(backsig_out);
823         }
824     }
825  
826   return rc;
827 }
828
829
830 static int
831 write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
832                   struct revocation_key *revkey )
833 {
834     PACKET *pkt;
835     PKT_signature *sig;
836     int rc=0;
837     KBNODE node;
838     PKT_public_key *pk;
839
840     if( opt.verbose )
841         log_info(_("writing direct signature\n"));
842
843     /* get the pk packet from the pub_tree */
844     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
845     if( !node )
846         BUG();
847     pk = node->pkt->pkt.public_key;
848
849     /* we have to cache the key, so that the verification of the signature
850      * creation is able to retrieve the public key */
851     cache_public_key (pk);
852
853     /* and make the signature */
854     rc = make_keysig_packet(&sig,pk,NULL,NULL,sk,0x1F,0,0,0,0,
855                             keygen_add_revkey,revkey);
856     if( rc ) {
857         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
858         return rc;
859     }
860
861     pkt = m_alloc_clear( sizeof *pkt );
862     pkt->pkttype = PKT_SIGNATURE;
863     pkt->pkt.signature = sig;
864     add_kbnode( root, new_kbnode( pkt ) );
865     return rc;
866 }
867
868 static int
869 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
870                unsigned int use )
871 {
872     PACKET *pkt;
873     PKT_signature *sig;
874     PKT_user_id *uid;
875     int rc=0;
876     KBNODE node;
877     PKT_public_key *pk;
878
879     if( opt.verbose )
880         log_info(_("writing self signature\n"));
881
882     /* get the uid packet from the list */
883     node = find_kbnode( root, PKT_USER_ID );
884     if( !node )
885         BUG(); /* no user id packet in tree */
886     uid = node->pkt->pkt.user_id;
887     /* get the pk packet from the pub_tree */
888     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
889     if( !node )
890         BUG();
891     pk = node->pkt->pkt.public_key;
892     pk->pubkey_usage = use;
893     /* we have to cache the key, so that the verification of the signature
894      * creation is able to retrieve the public key */
895     cache_public_key (pk);
896
897     /* and make the signature */
898     rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0, 0, 0, 0,
899                              keygen_add_std_prefs, pk );
900     if( rc ) {
901         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
902         return rc;
903     }
904
905     pkt = m_alloc_clear( sizeof *pkt );
906     pkt->pkttype = PKT_SIGNATURE;
907     pkt->pkt.signature = sig;
908     add_kbnode( root, new_kbnode( pkt ) );
909     return rc;
910 }
911
912 /* sub_sk is currently unused (reserved for backsigs) */
913 static int
914 write_keybinding( KBNODE root, KBNODE pub_root,
915                   PKT_secret_key *pri_sk, PKT_secret_key *sub_sk,
916                   unsigned int use )
917 {
918     PACKET *pkt;
919     PKT_signature *sig;
920     int rc=0;
921     KBNODE node;
922     PKT_public_key *pri_pk, *sub_pk;
923     struct opaque_data_usage_and_pk oduap;
924
925     if( opt.verbose )
926         log_info(_("writing key binding signature\n"));
927
928     /* get the pk packet from the pub_tree */
929     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
930     if( !node )
931         BUG();
932     pri_pk = node->pkt->pkt.public_key;
933     /* we have to cache the key, so that the verification of the signature
934      * creation is able to retrieve the public key */
935     cache_public_key (pri_pk);
936  
937     /* find the last subkey */
938     sub_pk = NULL;
939     for(node=pub_root; node; node = node->next ) {
940         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
941             sub_pk = node->pkt->pkt.public_key;
942     }
943     if( !sub_pk )
944         BUG();
945
946     /* and make the signature */
947     oduap.usage = use;
948     oduap.pk = sub_pk;
949     rc=make_keysig_packet(&sig, pri_pk, NULL, sub_pk, pri_sk, 0x18, 0, 0, 0, 0,
950                           keygen_add_key_flags_and_expire, &oduap );
951     if( rc ) {
952         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
953         return rc;
954     }
955
956     /* make a backsig */
957     if(use&PUBKEY_USAGE_SIG)
958       {
959         rc=make_backsig(sig,pri_pk,sub_pk,sub_sk);
960         if(rc)
961           return rc;
962       }
963
964     pkt = m_alloc_clear( sizeof *pkt );
965     pkt->pkttype = PKT_SIGNATURE;
966     pkt->pkt.signature = sig;
967     add_kbnode( root, new_kbnode( pkt ) );
968     return rc;
969 }
970
971
972 static int
973 gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
974         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
975 {
976     int rc;
977     int i;
978     PACKET *pkt;
979     PKT_secret_key *sk;
980     PKT_public_key *pk;
981     MPI skey[4];
982     MPI *factors;
983
984     assert( is_ELGAMAL(algo) );
985
986     if( nbits < 512 ) {
987         nbits = 1024;
988         log_info(_("keysize invalid; using %u bits\n"), nbits );
989     }
990
991     if( (nbits % 32) ) {
992         nbits = ((nbits + 31) / 32) * 32;
993         log_info(_("keysize rounded up to %u bits\n"), nbits );
994     }
995
996     rc = pubkey_generate( algo, nbits, skey, &factors );
997     if( rc ) {
998         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
999         return rc;
1000     }
1001
1002     sk = m_alloc_clear( sizeof *sk );
1003     pk = m_alloc_clear( sizeof *pk );
1004     sk->timestamp = pk->timestamp = make_timestamp();
1005     sk->version = pk->version = 4;
1006     if( expireval ) {
1007         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1008     }
1009     sk->pubkey_algo = pk->pubkey_algo = algo;
1010                        pk->pkey[0] = mpi_copy( skey[0] );
1011                        pk->pkey[1] = mpi_copy( skey[1] );
1012                        pk->pkey[2] = mpi_copy( skey[2] );
1013     sk->skey[0] = skey[0];
1014     sk->skey[1] = skey[1];
1015     sk->skey[2] = skey[2];
1016     sk->skey[3] = skey[3];
1017     sk->is_protected = 0;
1018     sk->protect.algo = 0;
1019
1020     sk->csum = checksum_mpi( sk->skey[3] );
1021     if( ret_sk ) /* return an unprotected version of the sk */
1022         *ret_sk = copy_secret_key( NULL, sk );
1023
1024     if( dek ) {
1025         sk->protect.algo = dek->algo;
1026         sk->protect.s2k = *s2k;
1027         rc = protect_secret_key( sk, dek );
1028         if( rc ) {
1029             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1030             free_public_key(pk);
1031             free_secret_key(sk);
1032             return rc;
1033         }
1034     }
1035
1036     pkt = m_alloc_clear(sizeof *pkt);
1037     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1038     pkt->pkt.public_key = pk;
1039     add_kbnode(pub_root, new_kbnode( pkt ));
1040
1041     /* don't know whether it makes sense to have the factors, so for now
1042      * we store them in the secret keyring (but they are not secret) */
1043     pkt = m_alloc_clear(sizeof *pkt);
1044     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1045     pkt->pkt.secret_key = sk;
1046     add_kbnode(sec_root, new_kbnode( pkt ));
1047     for(i=0; factors[i]; i++ )
1048         add_kbnode( sec_root,
1049                     make_mpi_comment_node("#:ELG_factor:", factors[i] ));
1050
1051     return 0;
1052 }
1053
1054
1055 /****************
1056  * Generate a DSA key
1057  */
1058 static int
1059 gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1060         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
1061 {
1062     int rc;
1063     int i;
1064     PACKET *pkt;
1065     PKT_secret_key *sk;
1066     PKT_public_key *pk;
1067     MPI skey[5];
1068     MPI *factors;
1069
1070     if( nbits > 1024 || nbits < 512 ) {
1071         nbits = 1024;
1072         log_info(_("keysize invalid; using %u bits\n"), nbits );
1073     }
1074
1075     if( (nbits % 64) ) {
1076         nbits = ((nbits + 63) / 64) * 64;
1077         log_info(_("keysize rounded up to %u bits\n"), nbits );
1078     }
1079
1080     rc = pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors );
1081     if( rc ) {
1082         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
1083         return rc;
1084     }
1085
1086     sk = m_alloc_clear( sizeof *sk );
1087     pk = m_alloc_clear( sizeof *pk );
1088     sk->timestamp = pk->timestamp = make_timestamp();
1089     sk->version = pk->version = 4;
1090     if( expireval ) {
1091         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1092     }
1093     sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
1094                        pk->pkey[0] = mpi_copy( skey[0] );
1095                        pk->pkey[1] = mpi_copy( skey[1] );
1096                        pk->pkey[2] = mpi_copy( skey[2] );
1097                        pk->pkey[3] = mpi_copy( skey[3] );
1098     sk->skey[0] = skey[0];
1099     sk->skey[1] = skey[1];
1100     sk->skey[2] = skey[2];
1101     sk->skey[3] = skey[3];
1102     sk->skey[4] = skey[4];
1103     sk->is_protected = 0;
1104     sk->protect.algo = 0;
1105
1106     sk->csum = checksum_mpi ( sk->skey[4] );
1107     if( ret_sk ) /* return an unprotected version of the sk */
1108         *ret_sk = copy_secret_key( NULL, sk );
1109
1110     if( dek ) {
1111         sk->protect.algo = dek->algo;
1112         sk->protect.s2k = *s2k;
1113         rc = protect_secret_key( sk, dek );
1114         if( rc ) {
1115             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1116             free_public_key(pk);
1117             free_secret_key(sk);
1118             return rc;
1119         }
1120     }
1121
1122     pkt = m_alloc_clear(sizeof *pkt);
1123     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1124     pkt->pkt.public_key = pk;
1125     add_kbnode(pub_root, new_kbnode( pkt ));
1126
1127     /* don't know whether it makes sense to have the factors, so for now
1128      * we store them in the secret keyring (but they are not secret)
1129      * p = 2 * q * f1 * f2 * ... * fn
1130      * We store only f1 to f_n-1;  fn can be calculated because p and q
1131      * are known.
1132      */
1133     pkt = m_alloc_clear(sizeof *pkt);
1134     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1135     pkt->pkt.secret_key = sk;
1136     add_kbnode(sec_root, new_kbnode( pkt ));
1137     for(i=1; factors[i]; i++ )  /* the first one is q */
1138         add_kbnode( sec_root,
1139                     make_mpi_comment_node("#:DSA_factor:", factors[i] ));
1140
1141     return 0;
1142 }
1143
1144
1145 /* 
1146  * Generate an RSA key.
1147  */
1148 static int
1149 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1150         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
1151 {
1152     int rc;
1153     PACKET *pkt;
1154     PKT_secret_key *sk;
1155     PKT_public_key *pk;
1156     MPI skey[6];
1157     MPI *factors;
1158
1159     assert( is_RSA(algo) );
1160
1161     if( nbits < 1024 ) {
1162         nbits = 1024;
1163         log_info(_("keysize invalid; using %u bits\n"), nbits );
1164     }
1165
1166     if( (nbits % 32) ) {
1167         nbits = ((nbits + 31) / 32) * 32;
1168         log_info(_("keysize rounded up to %u bits\n"), nbits );
1169     }
1170
1171     rc = pubkey_generate( algo, nbits, skey, &factors );
1172     if( rc ) {
1173         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
1174         return rc;
1175     }
1176
1177     sk = m_alloc_clear( sizeof *sk );
1178     pk = m_alloc_clear( sizeof *pk );
1179     sk->timestamp = pk->timestamp = make_timestamp();
1180     sk->version = pk->version = 4;
1181     if( expireval ) {
1182         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1183     }
1184     sk->pubkey_algo = pk->pubkey_algo = algo;
1185                        pk->pkey[0] = mpi_copy( skey[0] );
1186                        pk->pkey[1] = mpi_copy( skey[1] );
1187     sk->skey[0] = skey[0];
1188     sk->skey[1] = skey[1];
1189     sk->skey[2] = skey[2];
1190     sk->skey[3] = skey[3];
1191     sk->skey[4] = skey[4];
1192     sk->skey[5] = skey[5];
1193     sk->is_protected = 0;
1194     sk->protect.algo = 0;
1195
1196     sk->csum  = checksum_mpi (sk->skey[2] );
1197     sk->csum += checksum_mpi (sk->skey[3] );
1198     sk->csum += checksum_mpi (sk->skey[4] );
1199     sk->csum += checksum_mpi (sk->skey[5] );
1200     if( ret_sk ) /* return an unprotected version of the sk */
1201         *ret_sk = copy_secret_key( NULL, sk );
1202
1203     if( dek ) {
1204         sk->protect.algo = dek->algo;
1205         sk->protect.s2k = *s2k;
1206         rc = protect_secret_key( sk, dek );
1207         if( rc ) {
1208             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1209             free_public_key(pk);
1210             free_secret_key(sk);
1211             return rc;
1212         }
1213     }
1214
1215     pkt = m_alloc_clear(sizeof *pkt);
1216     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1217     pkt->pkt.public_key = pk;
1218     add_kbnode(pub_root, new_kbnode( pkt ));
1219
1220     pkt = m_alloc_clear(sizeof *pkt);
1221     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1222     pkt->pkt.secret_key = sk;
1223     add_kbnode(sec_root, new_kbnode( pkt ));
1224
1225     return 0;
1226 }
1227
1228
1229 /****************
1230  * check valid days:
1231  * return 0 on error or the multiplier
1232  */
1233 static int
1234 check_valid_days( const char *s )
1235 {
1236     if( !digitp(s) )
1237         return 0;
1238     for( s++; *s; s++)
1239         if( !digitp(s) )
1240             break;
1241     if( !*s )
1242         return 1;
1243     if( s[1] )
1244         return 0; /* e.g. "2323wc" */
1245     if( *s == 'd' || *s == 'D' )
1246         return 1;
1247     if( *s == 'w' || *s == 'W' )
1248         return 7;
1249     if( *s == 'm' || *s == 'M' )
1250         return 30;
1251     if( *s == 'y' || *s == 'Y' )
1252         return 365;
1253     return 0;
1254 }
1255
1256
1257 static void
1258 print_key_flags(int flags)
1259 {
1260   if(flags&PUBKEY_USAGE_SIG)
1261     tty_printf("%s ",_("Sign"));
1262
1263   if(flags&PUBKEY_USAGE_ENC)
1264     tty_printf("%s ",_("Encrypt"));
1265
1266   if(flags&PUBKEY_USAGE_AUTH)
1267     tty_printf("%s ",_("Authenticate"));
1268 }
1269
1270
1271 /* Returns the key flags */
1272 static unsigned int
1273 ask_key_flags(int algo)
1274 {
1275   const char *togglers=_("SsEeAaQq");
1276   char *answer=NULL;
1277   unsigned int current=0;
1278   unsigned int possible=openpgp_pk_algo_usage(algo);
1279
1280   if(strlen(togglers)!=8)
1281     BUG();
1282
1283   /* Preload the current set with the possible set, minus
1284      authentication, since nobody really uses auth yet. */
1285   current=possible&~PUBKEY_USAGE_AUTH;
1286
1287   for(;;)
1288     {
1289       tty_printf("\n");
1290       tty_printf(_("Possible actions for a %s key: "),
1291                  pubkey_algo_to_string(algo));
1292       print_key_flags(possible);
1293       tty_printf("\n");
1294       tty_printf(_("Current allowed actions: "));
1295       print_key_flags(current);
1296       tty_printf("\n\n");
1297
1298       if(possible&PUBKEY_USAGE_SIG)
1299         tty_printf(_("   (%c) Toggle the sign capability\n"),
1300                    togglers[0]);
1301       if(possible&PUBKEY_USAGE_ENC)
1302         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1303                    togglers[2]);
1304       if(possible&PUBKEY_USAGE_AUTH)
1305         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1306                    togglers[4]);
1307
1308       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1309       tty_printf("\n");
1310
1311       m_free(answer);
1312       answer = cpr_get("keygen.flags",_("Your selection? "));
1313       cpr_kill_prompt();
1314
1315       if(strlen(answer)>1)
1316         continue;
1317       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1318         break;
1319       else if((*answer==togglers[0] || *answer==togglers[1])
1320               && possible&PUBKEY_USAGE_SIG)
1321         {
1322           if(current&PUBKEY_USAGE_SIG)
1323             current&=~PUBKEY_USAGE_SIG;
1324           else
1325             current|=PUBKEY_USAGE_SIG;
1326         }
1327       else if((*answer==togglers[2] || *answer==togglers[3])
1328               && possible&PUBKEY_USAGE_ENC)
1329         {
1330           if(current&PUBKEY_USAGE_ENC)
1331             current&=~PUBKEY_USAGE_ENC;
1332           else
1333             current|=PUBKEY_USAGE_ENC;
1334         }
1335       else if((*answer==togglers[4] || *answer==togglers[5])
1336               && possible&PUBKEY_USAGE_AUTH)
1337         {
1338           if(current&PUBKEY_USAGE_AUTH)
1339             current&=~PUBKEY_USAGE_AUTH;
1340           else
1341             current|=PUBKEY_USAGE_AUTH;
1342         }
1343     }
1344
1345   m_free(answer);
1346
1347   return current;
1348 }
1349
1350
1351 /****************
1352  * Returns: 0 to create both a DSA and a Elgamal key.
1353  *          and only if key flags are to be written the desired usage.
1354  */
1355 static int
1356 ask_algo (int addmode, unsigned int *r_usage)
1357 {
1358     char *answer;
1359     int algo;
1360
1361     *r_usage = 0;
1362     tty_printf(_("Please select what kind of key you want:\n"));
1363     if( !addmode )
1364         tty_printf(_("   (%d) DSA and Elgamal (default)\n"), 1 );
1365     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
1366     if (opt.expert)
1367       tty_printf(  _("   (%d) DSA (set your own capabilities)\n"), 3 );
1368     if( addmode )
1369         tty_printf(_("   (%d) Elgamal (encrypt only)\n"), 4 );
1370     tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
1371     if (addmode)
1372         tty_printf(_("   (%d) RSA (encrypt only)\n"), 6 );
1373     if (opt.expert)
1374       tty_printf(  _("   (%d) RSA (set your own capabilities)\n"), 7 );
1375
1376     for(;;) {
1377         answer = cpr_get("keygen.algo",_("Your selection? "));
1378         cpr_kill_prompt();
1379         algo = *answer? atoi(answer): 1;
1380         m_free(answer);
1381         if( algo == 1 && !addmode ) {
1382             algo = 0;   /* create both keys */
1383             break;
1384         }
1385         else if( algo == 7 && opt.expert ) {
1386             algo = PUBKEY_ALGO_RSA;
1387             *r_usage=ask_key_flags(algo);
1388             break;
1389         }
1390         else if( algo == 6 && addmode ) {
1391             algo = PUBKEY_ALGO_RSA;
1392             *r_usage = PUBKEY_USAGE_ENC;
1393             break;
1394         }
1395         else if( algo == 5 ) {
1396             algo = PUBKEY_ALGO_RSA;
1397             *r_usage = PUBKEY_USAGE_SIG;
1398             break;
1399         }
1400         else if( algo == 4 && addmode ) {
1401             algo = PUBKEY_ALGO_ELGAMAL_E;
1402             *r_usage = PUBKEY_USAGE_ENC;
1403             break;
1404         }
1405         else if( algo == 3 && opt.expert ) {
1406             algo = PUBKEY_ALGO_DSA;
1407             *r_usage=ask_key_flags(algo);
1408             break;
1409         }
1410         else if( algo == 2 ) {
1411             algo = PUBKEY_ALGO_DSA;
1412             *r_usage = PUBKEY_USAGE_SIG;
1413             break;
1414         }
1415         else
1416             tty_printf(_("Invalid selection.\n"));
1417     }
1418
1419     return algo;
1420 }
1421
1422
1423 static unsigned
1424 ask_keysize( int algo )
1425 {
1426   unsigned nbits,min,def=2048,max=4096;
1427
1428   if(opt.expert)
1429     min=512;
1430   else
1431     min=1024;
1432
1433   switch(algo)
1434     {
1435     case PUBKEY_ALGO_DSA:
1436       if(opt.expert)
1437         {
1438           def=1024;
1439           max=1024;
1440         }
1441       else
1442         {
1443           tty_printf(_("DSA keypair will have %u bits.\n"),1024);
1444           return 1024;
1445         }
1446       break;
1447
1448     case PUBKEY_ALGO_RSA:
1449       min=1024;
1450       break;
1451     }
1452
1453   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1454              pubkey_algo_to_string(algo),min,max);
1455
1456   for(;;)
1457     {
1458       char *prompt,*answer;
1459
1460 #define PROMPTSTRING _("What keysize do you want? (%u) ")
1461
1462       prompt=m_alloc(strlen(PROMPTSTRING)+20);
1463       sprintf(prompt,PROMPTSTRING,def);
1464
1465 #undef PROMPTSTRING
1466
1467       answer = cpr_get("keygen.size",prompt);
1468       cpr_kill_prompt();
1469       nbits = *answer? atoi(answer): def;
1470       m_free(prompt);
1471       m_free(answer);
1472       
1473       if(nbits<min || nbits>max)
1474         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1475                    pubkey_algo_to_string(algo),min,max);
1476       else
1477         break;
1478     }
1479
1480   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1481
1482   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1483     {
1484       nbits = ((nbits + 63) / 64) * 64;
1485       tty_printf(_("rounded up to %u bits\n"), nbits );
1486     }
1487   else if( (nbits % 32) )
1488     {
1489       nbits = ((nbits + 31) / 32) * 32;
1490       tty_printf(_("rounded up to %u bits\n"), nbits );
1491     }
1492
1493   return nbits;
1494 }
1495
1496
1497 /****************
1498  * Parse an expire string and return it's value in days.
1499  * Returns -1 on error.
1500  */
1501 int
1502 parse_expire_string( const char *string )
1503 {
1504     int mult;
1505     u32 abs_date=0;
1506     u32 curtime = make_timestamp();
1507     int valid_days;
1508
1509     if( !*string )
1510         valid_days = 0;
1511     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
1512         /* This calculation is not perfectly okay because we
1513          * are later going to simply multiply by 86400 and don't
1514          * correct for leapseconds.  A solution would be to change
1515          * the whole implemenation to work with dates and not intervals
1516          * which are required for v3 keys.
1517          */
1518         valid_days = abs_date/86400-curtime/86400+1;
1519     }
1520     else if( (mult=check_valid_days(string)) ) {
1521         valid_days = atoi(string) * mult;
1522         if( valid_days < 0 || valid_days > 39447 )
1523             valid_days = 0;
1524     }
1525     else {
1526         valid_days = -1;
1527     }
1528     return valid_days;
1529 }
1530
1531 /* object == 0 for a key, and 1 for a sig */
1532 u32
1533 ask_expire_interval(int object,const char *def_expire)
1534 {
1535     char *answer;
1536     int valid_days=0;
1537     u32 interval = 0;
1538
1539     switch(object)
1540       {
1541       case 0:
1542         if(def_expire)
1543           BUG();
1544         tty_printf(_("Please specify how long the key should be valid.\n"
1545                      "         0 = key does not expire\n"
1546                      "      <n>  = key expires in n days\n"
1547                      "      <n>w = key expires in n weeks\n"
1548                      "      <n>m = key expires in n months\n"
1549                      "      <n>y = key expires in n years\n"));
1550         break;
1551
1552       case 1:
1553         if(!def_expire)
1554           BUG();
1555         tty_printf(_("Please specify how long the signature should be valid.\n"
1556                      "         0 = signature does not expire\n"
1557                      "      <n>  = signature expires in n days\n"
1558                      "      <n>w = signature expires in n weeks\n"
1559                      "      <n>m = signature expires in n months\n"
1560                      "      <n>y = signature expires in n years\n"));
1561         break;
1562
1563       default:
1564         BUG();
1565       }
1566
1567     /* Note: The elgamal subkey for DSA has no expiration date because
1568      * it must be signed with the DSA key and this one has the expiration
1569      * date */
1570
1571     answer = NULL;
1572     for(;;)
1573       {
1574         u32 curtime=make_timestamp();
1575
1576         m_free(answer);
1577         if(object==0)
1578           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1579         else
1580           {
1581             char *prompt;
1582
1583 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1584             /* This will actually end up larger than necessary because
1585                of the 2 bytes for '%s' */
1586             prompt=m_alloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1587             sprintf(prompt,PROMPTSTRING,def_expire);
1588 #undef PROMPTSTRING
1589
1590             answer = cpr_get("siggen.valid",prompt);
1591             m_free(prompt);
1592
1593             if(*answer=='\0')
1594               answer=m_strdup(def_expire);
1595           }
1596         cpr_kill_prompt();
1597         trim_spaces(answer);
1598         valid_days = parse_expire_string( answer );
1599         if( valid_days < 0 ) {
1600           tty_printf(_("invalid value\n"));
1601           continue;
1602         }
1603
1604         if( !valid_days )
1605           {
1606             tty_printf((object==0)
1607                        ? _("Key does not expire at all\n")
1608                        : _("Signature does not expire at all\n"));
1609             interval = 0;
1610           }
1611         else {
1612           interval = valid_days * 86400L;
1613
1614           tty_printf(object==0
1615                      ? _("Key expires at %s\n")
1616                      : _("Signature expires at %s\n"),
1617                      asctimestamp((ulong)(curtime + interval) ) );
1618           /* FIXME: This check yields warning on alhas: Write a
1619              configure check and to this check here only for 32 bit
1620              machines */
1621           if( (time_t)((ulong)(curtime+interval)) < 0 )
1622             tty_printf(_("Your system can't display dates beyond 2038.\n"
1623                          "However, it will be correctly handled up to 2106.\n"));
1624         }
1625
1626         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1627                                                    _("Is this correct? (y/N) ")) )
1628           break;
1629       }
1630     m_free(answer);
1631     return interval;
1632 }
1633
1634 u32
1635 ask_expiredate()
1636 {
1637     u32 x = ask_expire_interval(0,NULL);
1638     return x? make_timestamp() + x : 0;
1639 }
1640
1641 static int
1642 has_invalid_email_chars( const char *s )
1643 {
1644     int at_seen=0;
1645     static char valid_chars[] = "01234567890_-."
1646                                 "abcdefghijklmnopqrstuvwxyz"
1647                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1648
1649     for( ; *s; s++ ) {
1650         if( *s & 0x80 )
1651             return 1;
1652         if( *s == '@' )
1653             at_seen=1;
1654         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1655             return 1;
1656         else if( at_seen && !strchr( valid_chars, *s ) )
1657             return 1;
1658     }
1659     return 0;
1660 }
1661
1662
1663 static char *
1664 ask_user_id( int mode )
1665 {
1666     char *answer;
1667     char *aname, *acomment, *amail, *uid;
1668
1669     if( !mode )
1670         tty_printf( _("\n"
1671 "You need a user ID to identify your key; "
1672                                         "the software constructs the user ID\n"
1673 "from the Real Name, Comment and Email Address in this form:\n"
1674 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1675     uid = aname = acomment = amail = NULL;
1676     for(;;) {
1677         char *p;
1678         int fail=0;
1679
1680         if( !aname ) {
1681             for(;;) {
1682                 m_free(aname);
1683                 aname = cpr_get("keygen.name",_("Real name: "));
1684                 trim_spaces(aname);
1685                 cpr_kill_prompt();
1686
1687                 if( opt.allow_freeform_uid )
1688                     break;
1689
1690                 if( strpbrk( aname, "<>" ) )
1691                     tty_printf(_("Invalid character in name\n"));
1692                 else if( digitp(aname) )
1693                     tty_printf(_("Name may not start with a digit\n"));
1694                 else if( strlen(aname) < 5 )
1695                     tty_printf(_("Name must be at least 5 characters long\n"));
1696                 else
1697                     break;
1698             }
1699         }
1700         if( !amail ) {
1701             for(;;) {
1702                 m_free(amail);
1703                 amail = cpr_get("keygen.email",_("Email address: "));
1704                 trim_spaces(amail);
1705                 cpr_kill_prompt();
1706                 if( !*amail || opt.allow_freeform_uid )
1707                     break;   /* no email address is okay */
1708                 else if( has_invalid_email_chars(amail)
1709                          || string_count_chr(amail,'@') != 1
1710                          || *amail == '@'
1711                          || amail[strlen(amail)-1] == '@'
1712                          || amail[strlen(amail)-1] == '.'
1713                          || strstr(amail, "..") )
1714                     tty_printf(_("Not a valid email address\n"));
1715                 else
1716                     break;
1717             }
1718         }
1719         if( !acomment ) {
1720             for(;;) {
1721                 m_free(acomment);
1722                 acomment = cpr_get("keygen.comment",_("Comment: "));
1723                 trim_spaces(acomment);
1724                 cpr_kill_prompt();
1725                 if( !*acomment )
1726                     break;   /* no comment is okay */
1727                 else if( strpbrk( acomment, "()" ) )
1728                     tty_printf(_("Invalid character in comment\n"));
1729                 else
1730                     break;
1731             }
1732         }
1733
1734
1735         m_free(uid);
1736         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1737         p = stpcpy(p, aname );
1738         if( *acomment )
1739             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1740         if( *amail )
1741             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1742
1743         /* append a warning if we do not have dev/random
1744          * or it is switched into  quick testmode */
1745         if( quick_random_gen(-1) )
1746             strcpy(p, " (INSECURE!)" );
1747
1748         /* print a note in case that UTF8 mapping has to be done */
1749         for(p=uid; *p; p++ ) {
1750             if( *p & 0x80 ) {
1751                 tty_printf(_("You are using the `%s' character set.\n"),
1752                            get_native_charset() );
1753                 break;
1754             }
1755         }
1756
1757         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1758         /* fixme: add a warning if this user-id already exists */
1759         if( !*amail && !opt.allow_freeform_uid
1760             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1761             fail = 1;
1762             tty_printf(_("Please don't put the email address "
1763                           "into the real name or the comment\n") );
1764         }
1765
1766         for(;;) {
1767             /* TRANSLATORS: These are the allowed answers in
1768                lower and uppercase.  Below you will find the matching
1769                string which should be translated accordingly and the
1770                letter changed to match the one in the answer string.
1771                
1772                  n = Change name
1773                  c = Change comment
1774                  e = Change email
1775                  o = Okay (ready, continue)
1776                  q = Quit
1777              */
1778             const char *ansstr = _("NnCcEeOoQq");
1779
1780             if( strlen(ansstr) != 10 )
1781                 BUG();
1782             if( cpr_enabled() ) {
1783                 answer = m_strdup(ansstr+6);
1784                 answer[1] = 0;
1785             }
1786             else {
1787                 answer = cpr_get("keygen.userid.cmd", fail?
1788                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1789                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1790                 cpr_kill_prompt();
1791             }
1792             if( strlen(answer) > 1 )
1793                 ;
1794             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1795                 m_free(aname); aname = NULL;
1796                 break;
1797             }
1798             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1799                 m_free(acomment); acomment = NULL;
1800                 break;
1801             }
1802             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1803                 m_free(amail); amail = NULL;
1804                 break;
1805             }
1806             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1807                 if( fail ) {
1808                     tty_printf(_("Please correct the error first\n"));
1809                 }
1810                 else {
1811                     m_free(aname); aname = NULL;
1812                     m_free(acomment); acomment = NULL;
1813                     m_free(amail); amail = NULL;
1814                     break;
1815                 }
1816             }
1817             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1818                 m_free(aname); aname = NULL;
1819                 m_free(acomment); acomment = NULL;
1820                 m_free(amail); amail = NULL;
1821                 m_free(uid); uid = NULL;
1822                 break;
1823             }
1824             m_free(answer);
1825         }
1826         m_free(answer);
1827         if( !amail && !acomment && !amail )
1828             break;
1829         m_free(uid); uid = NULL;
1830     }
1831     if( uid ) {
1832         char *p = native_to_utf8( uid );
1833         m_free( uid );
1834         uid = p;
1835     }
1836     return uid;
1837 }
1838
1839
1840 /* FIXME: We need a way to cancel this prompt. */
1841 static DEK *
1842 do_ask_passphrase( STRING2KEY **ret_s2k )
1843 {
1844     DEK *dek = NULL;
1845     STRING2KEY *s2k;
1846     const char *errtext = NULL;
1847
1848     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1849
1850     s2k = m_alloc_secure( sizeof *s2k );
1851     for(;;) {
1852         s2k->mode = opt.s2k_mode;
1853         s2k->hash_algo = S2K_DIGEST_ALGO;
1854         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1855                                  errtext, NULL);
1856         if( !dek ) {
1857             errtext = N_("passphrase not correctly repeated; try again");
1858             tty_printf(_("%s.\n"), _(errtext));
1859         }
1860         else if( !dek->keylen ) {
1861             m_free(dek); dek = NULL;
1862             m_free(s2k); s2k = NULL;
1863             tty_printf(_(
1864             "You don't want a passphrase - this is probably a *bad* idea!\n"
1865             "I will do it anyway.  You can change your passphrase at any time,\n"
1866             "using this program with the option \"--edit-key\".\n\n"));
1867             break;
1868         }
1869         else
1870             break; /* okay */
1871     }
1872     *ret_s2k = s2k;
1873     return dek;
1874 }
1875
1876
1877 static int
1878 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1879            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
1880            int is_subkey )
1881 {
1882   int rc=0;
1883
1884   if( !opt.batch )
1885     tty_printf(_(
1886 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1887 "some other action (type on the keyboard, move the mouse, utilize the\n"
1888 "disks) during the prime generation; this gives the random number\n"
1889 "generator a better chance to gain enough entropy.\n") );
1890
1891   if( algo == PUBKEY_ALGO_ELGAMAL_E )
1892     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1893                  is_subkey);
1894   else if( algo == PUBKEY_ALGO_DSA )
1895     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1896                  is_subkey);
1897   else if( algo == PUBKEY_ALGO_RSA )
1898     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1899                  is_subkey);
1900   else
1901     BUG();
1902
1903 #ifdef ENABLE_COMMENT_PACKETS
1904   if( !rc ) {
1905     add_kbnode( pub_root,
1906                 make_comment_node("#created by GNUPG v" VERSION " ("
1907                                   PRINTABLE_OS_NAME ")"));
1908     add_kbnode( sec_root,
1909                 make_comment_node("#created by GNUPG v" VERSION " ("
1910                                   PRINTABLE_OS_NAME ")"));
1911   }
1912 #endif
1913   return rc;
1914 }
1915
1916
1917 /****************
1918  * Generate a new user id packet, or return NULL if canceled
1919  */
1920 PKT_user_id *
1921 generate_user_id()
1922 {
1923     PKT_user_id *uid;
1924     char *p;
1925     size_t n;
1926
1927     p = ask_user_id( 1 );
1928     if( !p )
1929         return NULL;
1930     n = strlen(p);
1931     uid = m_alloc_clear( sizeof *uid + n - 1 );
1932     uid->len = n;
1933     strcpy(uid->name, p);
1934     uid->ref = 1;
1935     return uid;
1936 }
1937
1938
1939 static void
1940 release_parameter_list( struct para_data_s *r )
1941 {
1942     struct para_data_s *r2;
1943
1944     for( ; r ; r = r2 ) {
1945         r2 = r->next;
1946         if( r->key == pPASSPHRASE_DEK )
1947             m_free( r->u.dek );
1948         else if( r->key == pPASSPHRASE_S2K )
1949             m_free( r->u.s2k );
1950
1951         m_free(r);
1952     }
1953 }
1954
1955 static struct para_data_s *
1956 get_parameter( struct para_data_s *para, enum para_name key )
1957 {
1958     struct para_data_s *r;
1959
1960     for( r = para; r && r->key != key; r = r->next )
1961         ;
1962     return r;
1963 }
1964
1965 static const char *
1966 get_parameter_value( struct para_data_s *para, enum para_name key )
1967 {
1968     struct para_data_s *r = get_parameter( para, key );
1969     return (r && *r->u.value)? r->u.value : NULL;
1970 }
1971
1972 static int
1973 get_parameter_algo( struct para_data_s *para, enum para_name key )
1974 {
1975     int i;
1976     struct para_data_s *r = get_parameter( para, key );
1977     if( !r )
1978         return -1;
1979     if( digitp( r->u.value ) )
1980         i = atoi( r->u.value );
1981     else
1982         i = string_to_pubkey_algo( r->u.value );
1983     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1984       i = 0; /* we don't want to allow generation of these algorithms */
1985     return i;
1986 }
1987
1988 /* 
1989  * parse the usage parameter and set the keyflags.  Return true on error.
1990  */
1991 static int
1992 parse_parameter_usage (const char *fname,
1993                        struct para_data_s *para, enum para_name key)
1994 {
1995     struct para_data_s *r = get_parameter( para, key );
1996     char *p, *pn;
1997     unsigned int use;
1998
1999     if( !r )
2000         return 0; /* none (this is an optional parameter)*/
2001     
2002     use = 0;
2003     pn = r->u.value;
2004     while ( (p = strsep (&pn, " \t,")) ) {
2005         if ( !*p)
2006             ;
2007         else if ( !ascii_strcasecmp (p, "sign") )
2008             use |= PUBKEY_USAGE_SIG;
2009         else if ( !ascii_strcasecmp (p, "encrypt") )
2010             use |= PUBKEY_USAGE_ENC;
2011         else if ( !ascii_strcasecmp (p, "auth") )
2012             use |= PUBKEY_USAGE_AUTH;
2013         else {
2014             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2015             return -1; /* error */
2016         }
2017     }
2018     r->u.usage = use;
2019     return 0;
2020 }
2021
2022 static int
2023 parse_revocation_key (const char *fname,
2024                       struct para_data_s *para, enum para_name key)
2025 {
2026   struct para_data_s *r = get_parameter( para, key );
2027   struct revocation_key revkey;
2028   char *pn;
2029   int i;
2030
2031   if( !r )
2032     return 0; /* none (this is an optional parameter) */
2033
2034   pn = r->u.value;
2035
2036   revkey.class=0x80;
2037   revkey.algid=atoi(pn);
2038   if(!revkey.algid)
2039     goto fail;
2040
2041   /* Skip to the fpr */
2042   while(*pn && *pn!=':')
2043     pn++;
2044
2045   if(*pn!=':')
2046     goto fail;
2047
2048   pn++;
2049
2050   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2051     {
2052       int c=hextobyte(pn);
2053       if(c==-1)
2054         goto fail;
2055
2056       revkey.fpr[i]=c;
2057     }
2058
2059   /* skip to the tag */
2060   while(*pn && *pn!='s' && *pn!='S')
2061     pn++;
2062
2063   if(ascii_strcasecmp(pn,"sensitive")==0)
2064     revkey.class|=0x40;
2065
2066   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2067
2068   return 0;
2069
2070   fail:
2071   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2072   return -1; /* error */
2073 }
2074
2075
2076 static u32
2077 get_parameter_u32( struct para_data_s *para, enum para_name key )
2078 {
2079     struct para_data_s *r = get_parameter( para, key );
2080
2081     if( !r )
2082         return 0;
2083     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2084         return r->u.expire;
2085     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2086         return r->u.usage;
2087
2088     return (unsigned int)strtoul( r->u.value, NULL, 10 );
2089 }
2090
2091 static unsigned int
2092 get_parameter_uint( struct para_data_s *para, enum para_name key )
2093 {
2094     return get_parameter_u32( para, key );
2095 }
2096
2097 static DEK *
2098 get_parameter_dek( struct para_data_s *para, enum para_name key )
2099 {
2100     struct para_data_s *r = get_parameter( para, key );
2101     return r? r->u.dek : NULL;
2102 }
2103
2104 static STRING2KEY *
2105 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2106 {
2107     struct para_data_s *r = get_parameter( para, key );
2108     return r? r->u.s2k : NULL;
2109 }
2110
2111 static struct revocation_key *
2112 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2113 {
2114     struct para_data_s *r = get_parameter( para, key );
2115     return r? &r->u.revkey : NULL;
2116 }
2117
2118 static int
2119 proc_parameter_file( struct para_data_s *para, const char *fname,
2120                      struct output_control_s *outctrl, int card )
2121 {
2122     struct para_data_s *r;
2123     const char *s1, *s2, *s3;
2124     size_t n;
2125     char *p;
2126     int i;
2127
2128     /* Check that we have all required parameters. */
2129     assert( get_parameter( para, pKEYTYPE ) );
2130     i = get_parameter_algo( para, pKEYTYPE );
2131     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
2132         r = get_parameter( para, pKEYTYPE );
2133         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2134         return -1;
2135     }
2136
2137     if (parse_parameter_usage (fname, para, pKEYUSAGE))
2138         return -1;
2139
2140     i = get_parameter_algo( para, pSUBKEYTYPE );
2141     if( i > 0 && check_pubkey_algo( i ) ) {
2142         r = get_parameter( para, pSUBKEYTYPE );
2143         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2144         return -1;
2145     }
2146     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
2147         return -1;
2148
2149
2150     if( !get_parameter_value( para, pUSERID ) ) {
2151         /* create the formatted user ID */
2152         s1 = get_parameter_value( para, pNAMEREAL );
2153         s2 = get_parameter_value( para, pNAMECOMMENT );
2154         s3 = get_parameter_value( para, pNAMEEMAIL );
2155         if( s1 || s2 || s3 ) {
2156             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2157             r = m_alloc_clear( sizeof *r + n + 20 );
2158             r->key = pUSERID;
2159             p = r->u.value;
2160             if( s1 )
2161                 p = stpcpy(p, s1 );
2162             if( s2 )
2163                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2164             if( s3 )
2165                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2166             r->next = para;
2167             para = r;
2168         }
2169     }
2170
2171     /* Set preferences, if any. */
2172     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2173
2174     /* Set revoker, if any. */
2175     if (parse_revocation_key (fname, para, pREVOKER))
2176       return -1;
2177
2178     /* make DEK and S2K from the Passphrase */
2179     r = get_parameter( para, pPASSPHRASE );
2180     if( r && *r->u.value ) {
2181         /* we have a plain text passphrase - create a DEK from it.
2182          * It is a little bit ridiculous to keep it ih secure memory
2183          * but becuase we do this alwasy, why not here */
2184         STRING2KEY *s2k;
2185         DEK *dek;
2186
2187         s2k = m_alloc_secure( sizeof *s2k );
2188         s2k->mode = opt.s2k_mode;
2189         s2k->hash_algo = S2K_DIGEST_ALGO;
2190         set_next_passphrase( r->u.value );
2191         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2192                                  NULL, NULL);
2193         set_next_passphrase( NULL );
2194         assert( dek );
2195         memset( r->u.value, 0, strlen(r->u.value) );
2196
2197         r = m_alloc_clear( sizeof *r );
2198         r->key = pPASSPHRASE_S2K;
2199         r->u.s2k = s2k;
2200         r->next = para;
2201         para = r;
2202         r = m_alloc_clear( sizeof *r );
2203         r->key = pPASSPHRASE_DEK;
2204         r->u.dek = dek;
2205         r->next = para;
2206         para = r;
2207     }
2208
2209     /* make KEYEXPIRE from Expire-Date */
2210     r = get_parameter( para, pEXPIREDATE );
2211     if( r && *r->u.value ) {
2212         i = parse_expire_string( r->u.value );
2213         if( i < 0 ) {
2214             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2215             return -1;
2216         }
2217         r->u.expire = i * 86400L;
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 = i * 86400L;
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
2720 static void
2721 do_generate_keypair( struct para_data_s *para,
2722                      struct output_control_s *outctrl, int card )
2723 {
2724     KBNODE pub_root = NULL;
2725     KBNODE sec_root = NULL;
2726     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2727     const char *s;
2728     struct revocation_key *revkey;
2729     int rc;
2730     int did_sub = 0;
2731
2732     if( outctrl->dryrun ) {
2733         log_info("dry-run mode - key generation skipped\n");
2734         return;
2735     }
2736
2737
2738     if( outctrl->use_files ) {
2739         if( outctrl->pub.newfname ) {
2740             iobuf_close(outctrl->pub.stream);
2741             outctrl->pub.stream = NULL;
2742             if (outctrl->pub.fname)
2743               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
2744             m_free( outctrl->pub.fname );
2745             outctrl->pub.fname =  outctrl->pub.newfname;
2746             outctrl->pub.newfname = NULL;
2747
2748             if (is_secured_filename (outctrl->pub.fname) ) {
2749                 outctrl->pub.stream = NULL;
2750                 errno = EPERM;
2751             }
2752             else
2753                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2754             if( !outctrl->pub.stream ) {
2755                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
2756                                                      strerror(errno) );
2757                 return;
2758             }
2759             if( opt.armor ) {
2760                 outctrl->pub.afx.what = 1;
2761                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2762                                                     &outctrl->pub.afx );
2763             }
2764         }
2765         if( outctrl->sec.newfname ) {
2766             mode_t oldmask;
2767
2768             iobuf_close(outctrl->sec.stream);
2769             outctrl->sec.stream = NULL;
2770             if (outctrl->sec.fname)
2771               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
2772             m_free( outctrl->sec.fname );
2773             outctrl->sec.fname =  outctrl->sec.newfname;
2774             outctrl->sec.newfname = NULL;
2775
2776             oldmask = umask (077);
2777             if (is_secured_filename (outctrl->sec.fname) ) {
2778                 outctrl->sec.stream = NULL;
2779                 errno = EPERM;
2780             }
2781             else
2782                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2783             umask (oldmask);
2784             if( !outctrl->sec.stream ) {
2785                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
2786                                                      strerror(errno) );
2787                 return;
2788             }
2789             if( opt.armor ) {
2790                 outctrl->sec.afx.what = 5;
2791                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2792                                                     &outctrl->sec.afx );
2793             }
2794         }
2795         assert( outctrl->pub.stream );
2796         assert( outctrl->sec.stream );
2797         if( opt.verbose ) {
2798             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2799             if (card)
2800               log_info (_("writing secret key stub to `%s'\n"),
2801                         outctrl->sec.fname);
2802             else
2803               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2804         }
2805     }
2806
2807
2808     /* we create the packets as a tree of kbnodes. Because the structure
2809      * we create is known in advance we simply generate a linked list
2810      * The first packet is a dummy comment packet which we flag
2811      * as deleted.  The very first packet must always be a KEY packet.
2812      */
2813     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
2814     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
2815
2816     if (!card)
2817       {
2818         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2819                         get_parameter_uint( para, pKEYLENGTH ),
2820                         pub_root, sec_root,
2821                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2822                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2823                         &pri_sk,
2824                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
2825       }
2826     else
2827       {
2828         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root,
2829                            get_parameter_u32 (para, pKEYEXPIRE), para);
2830         if (!rc)
2831           {
2832             pri_sk = sec_root->next->pkt->pkt.secret_key;
2833             assert (pri_sk);
2834           }
2835       }
2836
2837     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2838       {
2839         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
2840         if(!rc)
2841           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
2842       }
2843
2844     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
2845         write_uid(pub_root, s );
2846         if( !rc )
2847             write_uid(sec_root, s );
2848         if( !rc )
2849             rc = write_selfsig(pub_root, pub_root, pri_sk,
2850                                get_parameter_uint (para, pKEYUSAGE));
2851         if( !rc )
2852             rc = write_selfsig(sec_root, pub_root, pri_sk,
2853                                get_parameter_uint (para, pKEYUSAGE));
2854     }
2855
2856     /* Write the auth key to the card before the encryption key.  This
2857        is a partial workaround for a PGP bug (as of this writing, all
2858        versions including 8.1), that causes it to try and encrypt to
2859        the most recent subkey regardless of whether that subkey is
2860        actually an encryption type.  In this case, the auth key is an
2861        RSA key so it succeeds. */
2862
2863     if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
2864       {
2865         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root,
2866                            get_parameter_u32 (para, pKEYEXPIRE), para);
2867         
2868         if (!rc)
2869           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2870         if (!rc)
2871           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2872       }
2873
2874     if( !rc && get_parameter( para, pSUBKEYTYPE ) )
2875       {
2876         if (!card)
2877           {
2878             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2879                             get_parameter_uint( para, pSUBKEYLENGTH ),
2880                             pub_root, sec_root,
2881                             get_parameter_dek( para, pPASSPHRASE_DEK ),
2882                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
2883                             &sub_sk,
2884                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
2885           }
2886         else
2887           {
2888             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
2889               {
2890                 /* A backup of the encryption key has been requested.
2891                    Generate the key i software and import it then to
2892                    the card.  Write a backup file. */
2893                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
2894                                                pub_root, sec_root,
2895                                                get_parameter_u32 (para,
2896                                                                   pKEYEXPIRE),
2897                                                para, s);
2898               }
2899             else
2900               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
2901                                  get_parameter_u32 (para, pKEYEXPIRE), para);
2902           }
2903
2904         if( !rc )
2905           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
2906                                 get_parameter_uint (para, pSUBKEYUSAGE));
2907         if( !rc )
2908           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
2909                                 get_parameter_uint (para, pSUBKEYUSAGE));
2910         did_sub = 1;
2911       }
2912
2913     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2914         rc = write_keyblock( outctrl->pub.stream, pub_root );
2915         if( rc )
2916             log_error("can't write public key: %s\n", g10_errstr(rc) );
2917         if( !rc ) {
2918             rc = write_keyblock( outctrl->sec.stream, sec_root );
2919             if( rc )
2920                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2921         }
2922
2923     }
2924     else if( !rc ) { /* write to the standard keyrings */
2925         KEYDB_HANDLE pub_hd = keydb_new (0);
2926         KEYDB_HANDLE sec_hd = keydb_new (1);
2927
2928         /* FIXME: we may have to create the keyring first */
2929         rc = keydb_locate_writable (pub_hd, NULL);
2930         if (rc) 
2931             log_error (_("no writable public keyring found: %s\n"),
2932                        g10_errstr (rc));
2933
2934         if (!rc) {  
2935             rc = keydb_locate_writable (sec_hd, NULL);
2936             if (rc) 
2937                 log_error (_("no writable secret keyring found: %s\n"),
2938                            g10_errstr (rc));
2939         }
2940
2941         if (!rc && opt.verbose) {
2942             log_info(_("writing public key to `%s'\n"),
2943                      keydb_get_resource_name (pub_hd));
2944             if (card)
2945               log_info (_("writing secret key stub to `%s'\n"),
2946                         keydb_get_resource_name (sec_hd));
2947             else
2948               log_info(_("writing secret key to `%s'\n"),
2949                        keydb_get_resource_name (sec_hd));
2950         }
2951
2952         if (!rc) {
2953             rc = keydb_insert_keyblock (pub_hd, pub_root);
2954             if (rc)
2955                 log_error (_("error writing public keyring `%s': %s\n"),
2956                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2957         }
2958
2959         if (!rc) {
2960             rc = keydb_insert_keyblock (sec_hd, sec_root);
2961             if (rc)
2962                 log_error (_("error writing secret keyring `%s': %s\n"),
2963                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2964         }
2965
2966         keydb_release (pub_hd);
2967         keydb_release (sec_hd);
2968
2969         if (!rc) {
2970             int no_enc_rsa =
2971                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2972                 && get_parameter_uint( para, pKEYUSAGE )
2973                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2974             PKT_public_key *pk = find_kbnode (pub_root, 
2975                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2976
2977             keyid_from_pk(pk,pk->main_keyid);
2978             register_trusted_keyid(pk->main_keyid);
2979
2980             update_ownertrust (pk,
2981                                ((get_ownertrust (pk) & ~TRUST_MASK)
2982                                 | TRUST_ULTIMATE ));
2983
2984             if (!opt.batch) {
2985                 tty_printf(_("public and secret key created and signed.\n") );
2986                 tty_printf("\n");
2987                 list_keyblock(pub_root,0,1,NULL);
2988             }
2989             
2990
2991             if( !opt.batch
2992                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2993                      || no_enc_rsa )
2994                 && !get_parameter( para, pSUBKEYTYPE ) )
2995             {
2996                 tty_printf(_("Note that this key cannot be used for "
2997                              "encryption.  You may want to use\n"
2998                              "the command \"--edit-key\" to generate a "
2999                              "subkey for this purpose.\n") );
3000             }
3001         }
3002     }
3003
3004     if( rc ) {
3005         if( opt.batch )
3006             log_error("key generation failed: %s\n", g10_errstr(rc) );
3007         else
3008             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
3009         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3010     }
3011     else {
3012         PKT_public_key *pk = find_kbnode (pub_root, 
3013                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3014         print_status_key_created (did_sub? 'B':'P', pk,
3015                                   get_parameter_value (para, pHANDLE));
3016     }
3017     release_kbnode( pub_root );
3018     release_kbnode( sec_root );
3019
3020     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
3021       free_secret_key(pri_sk); /* shallow copy in card mode. */
3022     if( sub_sk )
3023         free_secret_key(sub_sk);
3024 }
3025
3026
3027 /****************
3028  * add a new subkey to an existing key.
3029  * Returns true if a new key has been generated and put into the keyblocks.
3030  */
3031 int
3032 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
3033 {
3034     int okay=0, rc=0;
3035     KBNODE node;
3036     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3037     int algo;
3038     unsigned int use;
3039     u32 expire;
3040     unsigned nbits;
3041     char *passphrase = NULL;
3042     DEK *dek = NULL;
3043     STRING2KEY *s2k = NULL;
3044     u32 cur_time;
3045     int ask_pass = 0;
3046
3047     /* break out the primary secret key */
3048     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3049     if( !node ) {
3050         log_error("Oops; secret key not found anymore!\n");
3051         goto leave;
3052     }
3053
3054     /* make a copy of the sk to keep the protected one in the keyblock */
3055     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
3056
3057     cur_time = make_timestamp();
3058     if( pri_sk->timestamp > cur_time ) {
3059         ulong d = pri_sk->timestamp - cur_time;
3060         log_info( d==1 ? _("key has been created %lu second "
3061                            "in future (time warp or clock problem)\n")
3062                        : _("key has been created %lu seconds "
3063                            "in future (time warp or clock problem)\n"), d );
3064         if( !opt.ignore_time_conflict ) {
3065             rc = G10ERR_TIME_CONFLICT;
3066             goto leave;
3067         }
3068     }
3069
3070     if (pri_sk->version < 4) {
3071         log_info (_("NOTE: creating subkeys for v3 keys "
3072                     "is not OpenPGP compliant\n"));
3073         goto leave;
3074     }
3075
3076     if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) {
3077         tty_printf(_("Secret parts of primary key are not available.\n"));
3078         rc = G10ERR_NO_SECKEY;
3079         goto leave;
3080     }
3081
3082
3083     /* Unprotect to get the passphrase.  */
3084     switch( is_secret_key_protected( pri_sk ) ) {
3085       case -1:
3086         rc = G10ERR_PUBKEY_ALGO;
3087         break;
3088       case 0:
3089         tty_printf(_("This key is not protected.\n"));
3090         break;
3091       case -2:
3092         tty_printf(_("Secret parts of primary key are stored on-card.\n"));
3093         ask_pass = 1;
3094         break;
3095       default:
3096         tty_printf(_("Key is protected.\n"));
3097         rc = check_secret_key( pri_sk, 0 );
3098         if( !rc )
3099             passphrase = get_last_passphrase();
3100         break;
3101     }
3102     if( rc )
3103         goto leave;
3104
3105     algo = ask_algo( 1, &use );
3106     assert(algo);
3107     nbits = ask_keysize( algo );
3108     expire = ask_expire_interval(0,NULL);
3109     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3110                                                   _("Really create? (y/N) ")))
3111         goto leave;
3112
3113     if (ask_pass)
3114         dek = do_ask_passphrase (&s2k);
3115     else if (passphrase) {
3116         s2k = m_alloc_secure( sizeof *s2k );
3117         s2k->mode = opt.s2k_mode;
3118         s2k->hash_algo = S2K_DIGEST_ALGO;
3119         set_next_passphrase( passphrase );
3120         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3121                                  NULL, NULL );
3122     }
3123
3124     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
3125                                       dek, s2k, &sub_sk, expire, 1 );
3126     if( !rc )
3127         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3128     if( !rc )
3129         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3130     if( !rc ) {
3131         okay = 1;
3132         write_status_text (STATUS_KEY_CREATED, "S");
3133     }
3134
3135   leave:
3136     if( rc )
3137         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3138     m_free( passphrase );
3139     m_free( dek );
3140     m_free( s2k );
3141     /* release the copy of the (now unprotected) secret keys */
3142     if( pri_sk )
3143         free_secret_key(pri_sk);
3144     if( sub_sk )
3145         free_secret_key(sub_sk);
3146     set_next_passphrase( NULL );
3147     return okay;
3148 }
3149
3150
3151 #ifdef ENABLE_CARD_SUPPORT
3152 /* Generate a subkey on a card. */
3153 int
3154 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3155                           int keyno, const char *serialno)
3156 {
3157   int okay=0, rc=0;
3158   KBNODE node;
3159   PKT_secret_key *pri_sk = NULL;
3160   int algo;
3161   unsigned int use;
3162   u32 expire;
3163   char *passphrase = NULL;
3164   u32 cur_time;
3165   struct para_data_s *para = NULL;
3166
3167   assert (keyno >= 1 && keyno <= 3);
3168
3169   para = xcalloc (1, sizeof *para + strlen (serialno) );
3170   para->key = pSERIALNO;
3171   strcpy (para->u.value, serialno);
3172
3173   /* Break out the primary secret key */
3174   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3175   if(!node)
3176     {
3177       log_error("Oops; secret key not found anymore!\n");
3178       goto leave;
3179     }
3180
3181   /* Make a copy of the sk to keep the protected one in the keyblock */
3182   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3183
3184   cur_time = make_timestamp();
3185   if (pri_sk->timestamp > cur_time)
3186     {
3187       ulong d = pri_sk->timestamp - cur_time;
3188       log_info (d==1 ? _("key has been created %lu second "
3189                          "in future (time warp or clock problem)\n")
3190                      : _("key has been created %lu seconds "
3191                          "in future (time warp or clock problem)\n"), d );
3192         if (!opt.ignore_time_conflict)
3193           {
3194             rc = G10ERR_TIME_CONFLICT;
3195             goto leave;
3196           }
3197     }
3198
3199   if (pri_sk->version < 4)
3200     {
3201       log_info (_("NOTE: creating subkeys for v3 keys "
3202                   "is not OpenPGP compliant\n"));
3203       goto leave;
3204     }
3205
3206   /* Unprotect to get the passphrase. */
3207   switch( is_secret_key_protected (pri_sk) )
3208     {
3209     case -1:
3210       rc = G10ERR_PUBKEY_ALGO;
3211       break;
3212     case 0:
3213       tty_printf("This key is not protected.\n");
3214       break;
3215     default:
3216       tty_printf("Key is protected.\n");
3217       rc = check_secret_key( pri_sk, 0 );
3218       if (!rc)
3219         passphrase = get_last_passphrase();
3220       break;
3221     }
3222   if (rc)
3223     goto leave;
3224
3225   algo = PUBKEY_ALGO_RSA;
3226   expire = ask_expire_interval (0,NULL);
3227   if (keyno == 1)
3228     use = PUBKEY_USAGE_SIG;
3229   else if (keyno == 2)
3230     use = PUBKEY_USAGE_ENC;
3231   else
3232     use = PUBKEY_USAGE_AUTH;
3233   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3234                                                _("Really create? (y/N) ")))
3235     goto leave;
3236
3237   if (passphrase)
3238     set_next_passphrase (passphrase);
3239   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock, expire, para);
3240   if (!rc)
3241     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, NULL, use);
3242   if (!rc)
3243     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, NULL, use);
3244   if (!rc)
3245     {
3246       okay = 1;
3247       write_status_text (STATUS_KEY_CREATED, "S");
3248     }
3249
3250  leave:
3251   if (rc)
3252     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3253   m_free (passphrase);
3254   /* Release the copy of the (now unprotected) secret keys. */
3255   if (pri_sk)
3256     free_secret_key (pri_sk);
3257   set_next_passphrase( NULL );
3258   release_parameter_list (para);
3259   return okay;
3260 }
3261 #endif /* !ENABLE_CARD_SUPPORT */
3262
3263
3264 /****************
3265  * Write a keyblock to an output stream
3266  */
3267 static int
3268 write_keyblock( IOBUF out, KBNODE node )
3269 {
3270     for( ; node ; node = node->next ) {
3271         int rc = build_packet( out, node->pkt );
3272         if( rc ) {
3273             log_error("build_packet(%d) failed: %s\n",
3274                         node->pkt->pkttype, g10_errstr(rc) );
3275             return G10ERR_WRITE_FILE;
3276         }
3277     }
3278     return 0;
3279 }
3280
3281
3282 static int
3283 gen_card_key (int algo, int keyno, int is_primary,
3284               KBNODE pub_root, KBNODE sec_root,
3285               u32 expireval, struct para_data_s *para)
3286 {
3287 #ifdef ENABLE_CARD_SUPPORT
3288   int rc;
3289   const char *s;
3290   struct agent_card_genkey_s info;
3291   PACKET *pkt;
3292   PKT_secret_key *sk;
3293   PKT_public_key *pk;
3294
3295   assert (algo == PUBKEY_ALGO_RSA);
3296   
3297
3298   rc = agent_scd_genkey (&info, keyno, 1);
3299 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3300 /*      { */
3301 /*        tty_printf ("\n"); */
3302 /*        log_error ("WARNING: key does already exists!\n"); */
3303 /*        tty_printf ("\n"); */
3304 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3305 /*                                    _("Replace existing key? "))) */
3306 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3307 /*      } */
3308
3309   if (rc)
3310     {
3311       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3312       return rc;
3313     }
3314   if ( !info.n || !info.e )
3315     {
3316       log_error ("communication error with SCD\n");
3317       mpi_free (info.n);
3318       mpi_free (info.e);
3319       return gpg_error (GPG_ERR_GENERAL);
3320     }
3321   
3322
3323   pk = xcalloc (1, sizeof *pk );
3324   sk = xcalloc (1, sizeof *sk );
3325   sk->timestamp = pk->timestamp = info.created_at;
3326   sk->version = pk->version = 4;
3327   if (expireval)
3328       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3329   sk->pubkey_algo = pk->pubkey_algo = algo;
3330   pk->pkey[0] = info.n;
3331   pk->pkey[1] = info.e; 
3332   sk->skey[0] = mpi_copy (pk->pkey[0]);
3333   sk->skey[1] = mpi_copy (pk->pkey[1]);
3334   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3335   sk->is_protected = 1;
3336   sk->protect.s2k.mode = 1002;
3337   s = get_parameter_value (para, pSERIALNO);
3338   if (s)
3339     {
3340       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3341            sk->protect.ivlen++, s += 2)
3342         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3343     }
3344
3345   pkt = xcalloc (1,sizeof *pkt);
3346   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3347   pkt->pkt.public_key = pk;
3348   add_kbnode(pub_root, new_kbnode( pkt ));
3349
3350   pkt = xcalloc (1,sizeof *pkt);
3351   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3352   pkt->pkt.secret_key = sk;
3353   add_kbnode(sec_root, new_kbnode( pkt ));
3354
3355   return 0;
3356 #else
3357   return -1;
3358 #endif /*!ENABLE_CARD_SUPPORT*/
3359 }
3360
3361
3362
3363 static int
3364 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3365                           KBNODE pub_root, KBNODE sec_root,
3366                           u32 expireval, struct para_data_s *para,
3367                           const char *backup_dir)
3368 {
3369 #ifdef ENABLE_CARD_SUPPORT
3370   int rc;
3371   const char *s;
3372   PACKET *pkt;
3373   PKT_secret_key *sk, *sk_unprotected, *sk_protected;
3374   PKT_public_key *pk;
3375   size_t n;
3376   int i;
3377
3378   rc = generate_raw_key (algo, 1024, make_timestamp (),
3379                          &sk_unprotected, &sk_protected);
3380   if (rc)
3381     return rc;
3382
3383   /* First, store the key to the card. */
3384   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3385   if (rc)
3386     {
3387       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3388       free_secret_key (sk_unprotected);
3389       free_secret_key (sk_protected);
3390       return rc;
3391     }
3392
3393   /* Get rid of the secret key parameters and store the serial numer. */
3394   sk = sk_unprotected;
3395   n = pubkey_get_nskey (sk->pubkey_algo);
3396   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3397     {
3398       mpi_free (sk->skey[i]);
3399       sk->skey[i] = NULL;
3400     }
3401   i = pubkey_get_npkey (sk->pubkey_algo);
3402   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3403   sk->is_protected = 1;
3404   sk->protect.s2k.mode = 1002;
3405   s = get_parameter_value (para, pSERIALNO);
3406   assert (s);
3407   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3408        sk->protect.ivlen++, s += 2)
3409     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3410
3411   /* Now write the *protected* secret key to the file.  */
3412   {
3413     char name_buffer[50];
3414     char *fname;
3415     IOBUF fp;
3416     mode_t oldmask;
3417
3418     keyid_from_sk (sk, NULL);
3419     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
3420              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3421
3422     fname = make_filename (backup_dir, name_buffer, NULL);
3423     oldmask = umask (077);
3424     if (is_secured_filename (fname))
3425       {
3426         fp = NULL;
3427         errno = EPERM;
3428       }
3429     else
3430       fp = iobuf_create (fname);
3431     umask (oldmask);
3432     if (!fp) 
3433       {
3434         log_error (_("can't create backup file `%s': %s\n"),
3435                    fname, strerror(errno) );
3436         m_free (fname);
3437         free_secret_key (sk_unprotected);
3438         free_secret_key (sk_protected);
3439         return G10ERR_OPEN_FILE;
3440       }
3441
3442     pkt = xcalloc (1, sizeof *pkt);
3443     pkt->pkttype = PKT_SECRET_KEY;
3444     pkt->pkt.secret_key = sk_protected;
3445     sk_protected = NULL;
3446
3447     rc = build_packet (fp, pkt);
3448     if (rc)
3449       {
3450         log_error("build packet failed: %s\n", g10_errstr(rc) );
3451         iobuf_cancel (fp);
3452       }
3453     else
3454       {
3455         byte array[MAX_FINGERPRINT_LEN];
3456         char *fprbuf, *p;
3457        
3458         iobuf_close (fp);
3459         iobuf_ioctl (NULL, 2, 0, (char*)fname);
3460         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3461
3462         fingerprint_from_sk (sk, array, &n);
3463         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
3464         for (i=0; i < n ; i++, p += 2)
3465           sprintf (p, "%02X", array[i]);
3466         *p++ = ' ';
3467         *p = 0;
3468
3469         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
3470                                       fprbuf,
3471                                       fname, strlen (fname),
3472                                       0);
3473         xfree (fprbuf);
3474       }
3475     free_packet (pkt);
3476     m_free (pkt);
3477     m_free (fname);
3478     if (rc)
3479       {
3480         free_secret_key (sk_unprotected);
3481         return rc;
3482       }
3483   }
3484
3485   /* Create the public key from the secret key. */
3486   pk = xcalloc (1, sizeof *pk );
3487   pk->timestamp = sk->timestamp;
3488   pk->version = sk->version;
3489   if (expireval)
3490       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3491   pk->pubkey_algo = sk->pubkey_algo;
3492   n = pubkey_get_npkey (sk->pubkey_algo);
3493   for (i=0; i < n; i++)
3494     pk->pkey[i] = mpi_copy (sk->skey[i]);
3495
3496   /* Build packets and add them to the node lists.  */
3497   pkt = xcalloc (1,sizeof *pkt);
3498   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3499   pkt->pkt.public_key = pk;
3500   add_kbnode(pub_root, new_kbnode( pkt ));
3501
3502   pkt = xcalloc (1,sizeof *pkt);
3503   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3504   pkt->pkt.secret_key = sk;
3505   add_kbnode(sec_root, new_kbnode( pkt ));
3506
3507   return 0;
3508 #else
3509   return -1;
3510 #endif /*!ENABLE_CARD_SUPPORT*/
3511 }
3512
3513
3514 #ifdef ENABLE_CARD_SUPPORT
3515 int
3516 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3517 {
3518   int rc;
3519   size_t n;
3520   MPI rsa_n, rsa_e, rsa_p, rsa_q;
3521   unsigned int nbits;
3522   unsigned char *template = NULL;
3523   unsigned char *tp;
3524   unsigned char m[128], e[4];
3525   size_t mlen, elen;
3526
3527   assert (is_RSA (sk->pubkey_algo));
3528   assert (!sk->is_protected);
3529
3530   rc = -1;
3531   /* Some basic checks on the key parameters. */
3532   rsa_n = sk->skey[0];
3533   rsa_e = sk->skey[1];
3534   rsa_p = sk->skey[3];
3535   rsa_q = sk->skey[4];
3536
3537   nbits = GET_NBITS (rsa_n);
3538   if (nbits != 1024)
3539     {
3540       log_error (_("length of RSA modulus is not %d\n"), 1024);
3541       goto leave;
3542     }
3543   nbits = GET_NBITS (rsa_e);
3544   if (nbits < 2 || nbits > 32)
3545     {
3546       log_error (_("public exponent too large (more than 32 bits)\n"));
3547       goto leave;
3548     }
3549   nbits = GET_NBITS (rsa_p);
3550   if (nbits != 512)
3551     {
3552       log_error (_("length of an RSA prime is not %d\n"), 512);
3553       goto leave;
3554     }
3555   nbits = GET_NBITS (rsa_q);
3556   if (nbits != 512)
3557     {
3558       log_error (_("length of an RSA prime is not %d\n"), 512);
3559       goto leave;
3560     }
3561
3562   
3563   /* We need the modulus later to calculate the fingerprint. */
3564   rc = copy_mpi (rsa_n, m, 128, &n);
3565   if (rc)
3566     goto leave;
3567   assert (n == 128);
3568   mlen = 128;
3569
3570   /* Build the private key template as described in section 4.3.3.6 of
3571      the OpenPGP card specs:
3572          0xC0   <length> public exponent
3573          0xC1   <length> prime p 
3574          0xC2   <length> prime q 
3575   */
3576   template = tp = xmalloc_secure (1+2 + 1+1+4 + 1+1+(512/8) + 1+1+(512/8));
3577   *tp++ = 0xC0;
3578   *tp++ = 4;
3579   rc = copy_mpi (rsa_e, tp, 4, &n);
3580   if (rc)
3581     goto leave;
3582   assert (n <= 4);
3583   memcpy (e, tp, n);  /* Save a copy of the exponent for later use.  */
3584   elen = n;
3585   if (n != 4)
3586     {
3587       memmove (tp+4-n, tp, 4-n);
3588       memset (tp, 0, 4-n);
3589     }                 
3590   tp += 4;
3591
3592   *tp++ = 0xC1;
3593   *tp++ = 64;
3594   rc = copy_mpi (rsa_p, tp, 64, &n);
3595   if (rc)
3596     goto leave;
3597   assert (n == 64);
3598   tp += 64;
3599
3600   *tp++ = 0xC2;
3601   *tp++ = 64;
3602   rc = copy_mpi (rsa_q, tp, 64, &n);
3603   if (rc)
3604     goto leave;
3605   assert (n == 64);
3606   tp += 64;
3607   assert (tp - template == 138);
3608
3609   rc = agent_openpgp_storekey (keyno,
3610                                template, tp - template,
3611                                sk->timestamp,
3612                                m, mlen,
3613                                e, elen);
3614
3615  leave:
3616   xfree (template);
3617   return rc;
3618 }
3619 #endif /*ENABLE_CARD_SUPPORT*/