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