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