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