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