Implemented PKA trust model
[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 i;
2067
2068     /* Check that we have all required parameters. */
2069     assert( get_parameter( para, pKEYTYPE ) );
2070     i = get_parameter_algo( para, pKEYTYPE );
2071     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
2072         r = get_parameter( para, pKEYTYPE );
2073         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2074         return -1;
2075     }
2076
2077     if (parse_parameter_usage (fname, para, pKEYUSAGE))
2078         return -1;
2079
2080     i = get_parameter_algo( para, pSUBKEYTYPE );
2081     if( i > 0 && check_pubkey_algo( i ) ) {
2082         r = get_parameter( para, pSUBKEYTYPE );
2083         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2084         return -1;
2085     }
2086     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
2087         return -1;
2088
2089
2090     if( !get_parameter_value( para, pUSERID ) ) {
2091         /* create the formatted user ID */
2092         s1 = get_parameter_value( para, pNAMEREAL );
2093         s2 = get_parameter_value( para, pNAMECOMMENT );
2094         s3 = get_parameter_value( para, pNAMEEMAIL );
2095         if( s1 || s2 || s3 ) {
2096             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2097             r = xmalloc_clear( sizeof *r + n + 20 );
2098             r->key = pUSERID;
2099             p = r->u.value;
2100             if( s1 )
2101                 p = stpcpy(p, s1 );
2102             if( s2 )
2103                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2104             if( s3 )
2105                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2106             r->next = para;
2107             para = r;
2108         }
2109     }
2110
2111     /* Set preferences, if any. */
2112     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2113
2114     /* Set revoker, if any. */
2115     if (parse_revocation_key (fname, para, pREVOKER))
2116       return -1;
2117
2118     /* make DEK and S2K from the Passphrase */
2119     r = get_parameter( para, pPASSPHRASE );
2120     if( r && *r->u.value ) {
2121         /* we have a plain text passphrase - create a DEK from it.
2122          * It is a little bit ridiculous to keep it ih secure memory
2123          * but becuase we do this alwasy, why not here */
2124         STRING2KEY *s2k;
2125         DEK *dek;
2126
2127         s2k = xmalloc_secure( sizeof *s2k );
2128         s2k->mode = opt.s2k_mode;
2129         s2k->hash_algo = S2K_DIGEST_ALGO;
2130         set_next_passphrase( r->u.value );
2131         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2132                                  NULL, NULL);
2133         set_next_passphrase( NULL );
2134         assert( dek );
2135         memset( r->u.value, 0, strlen(r->u.value) );
2136
2137         r = xmalloc_clear( sizeof *r );
2138         r->key = pPASSPHRASE_S2K;
2139         r->u.s2k = s2k;
2140         r->next = para;
2141         para = r;
2142         r = xmalloc_clear( sizeof *r );
2143         r->key = pPASSPHRASE_DEK;
2144         r->u.dek = dek;
2145         r->next = para;
2146         para = r;
2147     }
2148
2149     /* make KEYEXPIRE from Expire-Date */
2150     r = get_parameter( para, pEXPIREDATE );
2151     if( r && *r->u.value )
2152       {
2153         u32 seconds;
2154
2155         seconds = parse_expire_string( r->u.value );
2156         if( seconds == (u32)-1 )
2157           {
2158             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2159             return -1;
2160           }
2161         r->u.expire = seconds;
2162         r->key = pKEYEXPIRE;  /* change hat entry */
2163         /* also set it for the subkey */
2164         r = xmalloc_clear( sizeof *r + 20 );
2165         r->key = pSUBKEYEXPIRE;
2166         r->u.expire = seconds;
2167         r->next = para;
2168         para = r;
2169       }
2170
2171     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2172         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2173         return -1;
2174     }
2175
2176     do_generate_keypair( para, outctrl, card );
2177     return 0;
2178 }
2179
2180
2181 /****************
2182  * Kludge to allow non interactive key generation controlled
2183  * by a parameter file.
2184  * Note, that string parameters are expected to be in UTF-8
2185  */
2186 static void
2187 read_parameter_file( const char *fname )
2188 {
2189     static struct { const char *name;
2190                     enum para_name key;
2191     } keywords[] = {
2192         { "Key-Type",       pKEYTYPE},
2193         { "Key-Length",     pKEYLENGTH },
2194         { "Key-Usage",      pKEYUSAGE },
2195         { "Subkey-Type",    pSUBKEYTYPE },
2196         { "Subkey-Length",  pSUBKEYLENGTH },
2197         { "Subkey-Usage",   pSUBKEYUSAGE },
2198         { "Name-Real",      pNAMEREAL },
2199         { "Name-Email",     pNAMEEMAIL },
2200         { "Name-Comment",   pNAMECOMMENT },
2201         { "Expire-Date",    pEXPIREDATE },
2202         { "Passphrase",     pPASSPHRASE },
2203         { "Preferences",    pPREFERENCES },
2204         { "Revoker",        pREVOKER },
2205         { "Handle",         pHANDLE },
2206         { NULL, 0 }
2207     };
2208     IOBUF fp;
2209     byte *line;
2210     unsigned int maxlen, nline;
2211     char *p;
2212     int lnr;
2213     const char *err = NULL;
2214     struct para_data_s *para, *r;
2215     int i;
2216     struct output_control_s outctrl;
2217
2218     memset( &outctrl, 0, sizeof( outctrl ) );
2219
2220     if( !fname || !*fname)
2221       fname = "-";
2222
2223     fp = iobuf_open (fname);
2224     if (fp && is_secured_file (iobuf_get_fd (fp)))
2225       {
2226         iobuf_close (fp);
2227         fp = NULL;
2228         errno = EPERM;
2229       }
2230     if (!fp) {
2231       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2232       return;
2233     }
2234     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2235
2236     lnr = 0;
2237     err = NULL;
2238     para = NULL;
2239     maxlen = 1024;
2240     line = NULL;
2241     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2242         char *keyword, *value;
2243
2244         lnr++;
2245         if( !maxlen ) {
2246             err = "line too long";
2247             break;
2248         }
2249         for( p = line; isspace(*(byte*)p); p++ )
2250             ;
2251         if( !*p || *p == '#' )
2252             continue;
2253         keyword = p;
2254         if( *keyword == '%' ) {
2255             for( ; !isspace(*(byte*)p); p++ )
2256                 ;
2257             if( *p )
2258                 *p++ = 0;
2259             for( ; isspace(*(byte*)p); p++ )
2260                 ;
2261             value = p;
2262             trim_trailing_ws( value, strlen(value) );
2263             if( !ascii_strcasecmp( keyword, "%echo" ) )
2264                 log_info("%s\n", value );
2265             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2266                 outctrl.dryrun = 1;
2267             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2268                 outctrl.lnr = lnr;
2269                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2270                   print_status_key_not_created 
2271                     (get_parameter_value (para, pHANDLE));
2272                 release_parameter_list( para );
2273                 para = NULL;
2274             }
2275             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2276                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2277                     ; /* still the same file - ignore it */
2278                 else {
2279                     xfree( outctrl.pub.newfname );
2280                     outctrl.pub.newfname = xstrdup( value );
2281                     outctrl.use_files = 1;
2282                 }
2283             }
2284             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2285                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2286                     ; /* still the same file - ignore it */
2287                 else {
2288                    xfree( outctrl.sec.newfname );
2289                    outctrl.sec.newfname = xstrdup( value );
2290                    outctrl.use_files = 1;
2291                 }
2292             }
2293             else
2294                 log_info("skipping control `%s' (%s)\n", keyword, value );
2295
2296
2297             continue;
2298         }
2299
2300
2301         if( !(p = strchr( p, ':' )) || p == keyword ) {
2302             err = "missing colon";
2303             break;
2304         }
2305         if( *p )
2306             *p++ = 0;
2307         for( ; isspace(*(byte*)p); p++ )
2308             ;
2309         if( !*p ) {
2310             err = "missing argument";
2311             break;
2312         }
2313         value = p;
2314         trim_trailing_ws( value, strlen(value) );
2315
2316         for(i=0; keywords[i].name; i++ ) {
2317             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2318                 break;
2319         }
2320         if( !keywords[i].name ) {
2321             err = "unknown keyword";
2322             break;
2323         }
2324         if( keywords[i].key != pKEYTYPE && !para ) {
2325             err = "parameter block does not start with \"Key-Type\"";
2326             break;
2327         }
2328
2329         if( keywords[i].key == pKEYTYPE && para ) {
2330             outctrl.lnr = lnr;
2331             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2332               print_status_key_not_created
2333                 (get_parameter_value (para, pHANDLE));
2334             release_parameter_list( para );
2335             para = NULL;
2336         }
2337         else {
2338             for( r = para; r; r = r->next ) {
2339                 if( r->key == keywords[i].key )
2340                     break;
2341             }
2342             if( r ) {
2343                 err = "duplicate keyword";
2344                 break;
2345             }
2346         }
2347         r = xmalloc_clear( sizeof *r + strlen( value ) );
2348         r->lnr = lnr;
2349         r->key = keywords[i].key;
2350         strcpy( r->u.value, value );
2351         r->next = para;
2352         para = r;
2353     }
2354     if( err )
2355         log_error("%s:%d: %s\n", fname, lnr, err );
2356     else if( iobuf_error (fp) ) {
2357         log_error("%s:%d: read error\n", fname, lnr);
2358     }
2359     else if( para ) {
2360         outctrl.lnr = lnr;
2361         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2362           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2363     }
2364
2365     if( outctrl.use_files ) { /* close open streams */
2366         iobuf_close( outctrl.pub.stream );
2367         iobuf_close( outctrl.sec.stream );
2368
2369         /* Must invalidate that ugly cache to actually close it.  */
2370         if (outctrl.pub.fname)
2371           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2372         if (outctrl.sec.fname)
2373           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2374
2375         xfree( outctrl.pub.fname );
2376         xfree( outctrl.pub.newfname );
2377         xfree( outctrl.sec.fname );
2378         xfree( outctrl.sec.newfname );
2379     }
2380
2381     release_parameter_list( para );
2382     iobuf_close (fp);
2383 }
2384
2385
2386 /*
2387  * Generate a keypair (fname is only used in batch mode) If
2388  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2389  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2390  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2391  * generate in software, imported to the card and a backup file
2392  * written to directory given by this argument .
2393  */
2394 void
2395 generate_keypair (const char *fname, const char *card_serialno, 
2396                   const char *backup_encryption_dir)
2397 {
2398   unsigned int nbits;
2399   char *uid = NULL;
2400   DEK *dek;
2401   STRING2KEY *s2k;
2402   int algo;
2403   unsigned int use;
2404   int both = 0;
2405   u32 expire;
2406   struct para_data_s *para = NULL;
2407   struct para_data_s *r;
2408   struct output_control_s outctrl;
2409   
2410   memset( &outctrl, 0, sizeof( outctrl ) );
2411   
2412   if (opt.batch && card_serialno)
2413     {
2414       /* We don't yet support unattended key generation. */
2415       log_error (_("can't do this in batch mode\n"));
2416       return;
2417     }
2418   
2419   if (opt.batch)
2420     {
2421       read_parameter_file( fname );
2422       return;
2423     }
2424
2425   if (card_serialno)
2426     {
2427 #ifdef ENABLE_CARD_SUPPORT
2428       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2429       r->key = pSERIALNO;
2430       strcpy( r->u.value, card_serialno);
2431       r->next = para;
2432       para = r;
2433        
2434       algo = PUBKEY_ALGO_RSA;
2435        
2436       r = xcalloc (1, sizeof *r + 20 );
2437       r->key = pKEYTYPE;
2438       sprintf( r->u.value, "%d", algo );
2439       r->next = para;
2440       para = r;
2441       r = xcalloc (1, sizeof *r + 20 );
2442       r->key = pKEYUSAGE;
2443       strcpy (r->u.value, "sign");
2444       r->next = para;
2445       para = r;
2446        
2447       r = xcalloc (1, sizeof *r + 20 );
2448       r->key = pSUBKEYTYPE;
2449       sprintf( r->u.value, "%d", algo );
2450       r->next = para;
2451       para = r;
2452       r = xcalloc (1, sizeof *r + 20 );
2453       r->key = pSUBKEYUSAGE;
2454       strcpy (r->u.value, "encrypt");
2455       r->next = para;
2456       para = r;
2457        
2458       r = xcalloc (1, sizeof *r + 20 );
2459       r->key = pAUTHKEYTYPE;
2460       sprintf( r->u.value, "%d", algo );
2461       r->next = para;
2462       para = r;
2463
2464       if (backup_encryption_dir)
2465         {
2466           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2467           r->key = pBACKUPENCDIR;
2468           strcpy (r->u.value, backup_encryption_dir);
2469           r->next = para;
2470           para = r;
2471         }
2472 #endif /*ENABLE_CARD_SUPPORT*/
2473     }
2474   else
2475     {
2476       algo = ask_algo( 0, &use );
2477       if( !algo )
2478         { /* default: DSA with ElG subkey of the specified size */
2479           both = 1;
2480           r = xmalloc_clear( sizeof *r + 20 );
2481           r->key = pKEYTYPE;
2482           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2483           r->next = para;
2484           para = r;
2485           tty_printf(_("DSA keypair will have %u bits.\n"),1024);
2486           r = xmalloc_clear( sizeof *r + 20 );
2487           r->key = pKEYLENGTH;
2488           strcpy( r->u.value, "1024" );
2489           r->next = para;
2490           para = r;
2491           r = xmalloc_clear( sizeof *r + 20 );
2492           r->key = pKEYUSAGE;
2493           strcpy( r->u.value, "sign" );
2494           r->next = para;
2495           para = r;
2496            
2497           algo = PUBKEY_ALGO_ELGAMAL_E;
2498           r = xmalloc_clear( sizeof *r + 20 );
2499           r->key = pSUBKEYTYPE;
2500           sprintf( r->u.value, "%d", algo );
2501           r->next = para;
2502           para = r;
2503           r = xmalloc_clear( sizeof *r + 20 );
2504           r->key = pSUBKEYUSAGE;
2505           strcpy( r->u.value, "encrypt" );
2506           r->next = para;
2507           para = r;
2508         }
2509       else 
2510         {
2511           r = xmalloc_clear( sizeof *r + 20 );
2512           r->key = pKEYTYPE;
2513           sprintf( r->u.value, "%d", algo );
2514           r->next = para;
2515           para = r;
2516            
2517           if (use)
2518             {
2519               r = xmalloc_clear( sizeof *r + 25 );
2520               r->key = pKEYUSAGE;
2521               sprintf( r->u.value, "%s%s%s",
2522                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2523                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
2524                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
2525               r->next = para;
2526               para = r;
2527             }
2528            
2529         }
2530        
2531       nbits = ask_keysize( algo );
2532       r = xmalloc_clear( sizeof *r + 20 );
2533       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2534       sprintf( r->u.value, "%u", nbits);
2535       r->next = para;
2536       para = r;
2537     }
2538    
2539   expire = ask_expire_interval(0,NULL);
2540   r = xmalloc_clear( sizeof *r + 20 );
2541   r->key = pKEYEXPIRE;
2542   r->u.expire = expire;
2543   r->next = para;
2544   para = r;
2545   r = xmalloc_clear( sizeof *r + 20 );
2546   r->key = pSUBKEYEXPIRE;
2547   r->u.expire = expire;
2548   r->next = para;
2549   para = r;
2550
2551   uid = ask_user_id(0);
2552   if( !uid ) 
2553     {
2554       log_error(_("Key generation canceled.\n"));
2555       release_parameter_list( para );
2556       return;
2557     }
2558   r = xmalloc_clear( sizeof *r + strlen(uid) );
2559   r->key = pUSERID;
2560   strcpy( r->u.value, uid );
2561   r->next = para;
2562   para = r;
2563     
2564   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2565   if( dek )
2566     {
2567       r = xmalloc_clear( sizeof *r );
2568       r->key = pPASSPHRASE_DEK;
2569       r->u.dek = dek;
2570       r->next = para;
2571       para = r;
2572       r = xmalloc_clear( sizeof *r );
2573       r->key = pPASSPHRASE_S2K;
2574       r->u.s2k = s2k;
2575       r->next = para;
2576       para = r;
2577     }
2578     
2579   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2580   release_parameter_list( para );
2581 }
2582
2583
2584 #ifdef ENABLE_CARD_SUPPORT
2585 /* Generate a raw key and return it as a secret key packet.  The
2586    function will ask for the passphrase and return a protected as well
2587    as an unprotected copy of a new secret key packet.  0 is returned
2588    on success and the caller must then free the returned values.  */
2589 static int
2590 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
2591                   PKT_secret_key **r_sk_unprotected,
2592                   PKT_secret_key **r_sk_protected)
2593 {
2594   int rc;
2595   DEK *dek = NULL;
2596   STRING2KEY *s2k = NULL;
2597   PKT_secret_key *sk = NULL;
2598   int i;
2599   size_t nskey, npkey;
2600
2601   npkey = pubkey_get_npkey (algo);
2602   nskey = pubkey_get_nskey (algo);
2603   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
2604
2605   if (nbits < 512)
2606     {
2607       nbits = 512;
2608       log_info (_("keysize invalid; using %u bits\n"), nbits );
2609     }
2610
2611   if ((nbits % 32)) 
2612     {
2613       nbits = ((nbits + 31) / 32) * 32;
2614       log_info(_("keysize rounded up to %u bits\n"), nbits );
2615     }
2616
2617   dek = do_ask_passphrase (&s2k);
2618
2619   sk = xmalloc_clear (sizeof *sk);
2620   sk->timestamp = created_at;
2621   sk->version = 4;
2622   sk->pubkey_algo = algo;
2623
2624   rc = pubkey_generate (algo, nbits, sk->skey, NULL);
2625   if (rc)
2626     {
2627       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
2628       goto leave;
2629     }
2630
2631   for (i=npkey; i < nskey; i++)
2632     sk->csum += checksum_mpi (sk->skey[i]);
2633
2634   if (r_sk_unprotected) 
2635     *r_sk_unprotected = copy_secret_key (NULL, sk);
2636
2637   if (dek)
2638     {
2639       sk->protect.algo = dek->algo;
2640       sk->protect.s2k = *s2k;
2641       rc = protect_secret_key (sk, dek);
2642       if (rc)
2643         {
2644           log_error ("protect_secret_key failed: %s\n", g10_errstr(rc));
2645           goto leave;
2646         }
2647     }
2648   if (r_sk_protected)
2649     {
2650       *r_sk_protected = sk;
2651       sk = NULL;
2652     }
2653
2654  leave:
2655   if (sk)
2656     free_secret_key (sk);
2657   xfree (dek);
2658   xfree (s2k);
2659   return rc;
2660 }
2661 #endif /* ENABLE_CARD_SUPPORT */
2662
2663 /* Create and delete a dummy packet to start off a list of kbnodes. */
2664 static void
2665 start_tree(KBNODE *tree)
2666 {
2667   PACKET *pkt;
2668
2669   pkt=xmalloc_clear(sizeof(*pkt));
2670   pkt->pkttype=PKT_NONE;
2671   *tree=new_kbnode(pkt);
2672   delete_kbnode(*tree);
2673 }
2674
2675 static void
2676 do_generate_keypair( struct para_data_s *para,
2677                      struct output_control_s *outctrl, int card )
2678 {
2679     KBNODE pub_root = NULL;
2680     KBNODE sec_root = NULL;
2681     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2682     const char *s;
2683     struct revocation_key *revkey;
2684     int rc;
2685     int did_sub = 0;
2686
2687     if( outctrl->dryrun )
2688       {
2689         log_info("dry-run mode - key generation skipped\n");
2690         return;
2691       }
2692
2693     if( outctrl->use_files ) {
2694         if( outctrl->pub.newfname ) {
2695             iobuf_close(outctrl->pub.stream);
2696             outctrl->pub.stream = NULL;
2697             if (outctrl->pub.fname)
2698               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
2699             xfree( outctrl->pub.fname );
2700             outctrl->pub.fname =  outctrl->pub.newfname;
2701             outctrl->pub.newfname = NULL;
2702
2703             if (is_secured_filename (outctrl->pub.fname) ) {
2704                 outctrl->pub.stream = NULL;
2705                 errno = EPERM;
2706             }
2707             else
2708                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2709             if( !outctrl->pub.stream ) {
2710                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
2711                                                      strerror(errno) );
2712                 return;
2713             }
2714             if( opt.armor ) {
2715                 outctrl->pub.afx.what = 1;
2716                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2717                                                     &outctrl->pub.afx );
2718             }
2719         }
2720         if( outctrl->sec.newfname ) {
2721             mode_t oldmask;
2722
2723             iobuf_close(outctrl->sec.stream);
2724             outctrl->sec.stream = NULL;
2725             if (outctrl->sec.fname)
2726               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
2727             xfree( outctrl->sec.fname );
2728             outctrl->sec.fname =  outctrl->sec.newfname;
2729             outctrl->sec.newfname = NULL;
2730
2731             oldmask = umask (077);
2732             if (is_secured_filename (outctrl->sec.fname) ) {
2733                 outctrl->sec.stream = NULL;
2734                 errno = EPERM;
2735             }
2736             else
2737                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2738             umask (oldmask);
2739             if( !outctrl->sec.stream ) {
2740                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
2741                                                      strerror(errno) );
2742                 return;
2743             }
2744             if( opt.armor ) {
2745                 outctrl->sec.afx.what = 5;
2746                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2747                                                     &outctrl->sec.afx );
2748             }
2749         }
2750         assert( outctrl->pub.stream );
2751         assert( outctrl->sec.stream );
2752         if( opt.verbose ) {
2753             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2754             if (card)
2755               log_info (_("writing secret key stub to `%s'\n"),
2756                         outctrl->sec.fname);
2757             else
2758               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2759         }
2760     }
2761
2762
2763     /* we create the packets as a tree of kbnodes. Because the
2764      * structure we create is known in advance we simply generate a
2765      * linked list.  The first packet is a dummy packet which we flag
2766      * as deleted.  The very first packet must always be a KEY packet.
2767      */
2768     
2769     start_tree(&pub_root);
2770     start_tree(&sec_root);
2771
2772     if (!card)
2773       {
2774         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2775                         get_parameter_uint( para, pKEYLENGTH ),
2776                         pub_root, sec_root,
2777                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2778                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2779                         &pri_sk,
2780                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
2781       }
2782     else
2783       {
2784         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root,
2785                            get_parameter_u32 (para, pKEYEXPIRE), para);
2786         if (!rc)
2787           {
2788             pri_sk = sec_root->next->pkt->pkt.secret_key;
2789             assert (pri_sk);
2790           }
2791       }
2792
2793     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2794       {
2795         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
2796         if(!rc)
2797           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
2798       }
2799
2800     if( !rc && (s=get_parameter_value(para, pUSERID)) )
2801       {
2802         write_uid(pub_root, s );
2803         if( !rc )
2804           write_uid(sec_root, s );
2805
2806         if( !rc )
2807           rc = write_selfsigs(sec_root, pub_root, pri_sk,
2808                               get_parameter_uint (para, pKEYUSAGE));
2809       }
2810
2811     /* Write the auth key to the card before the encryption key.  This
2812        is a partial workaround for a PGP bug (as of this writing, all
2813        versions including 8.1), that causes it to try and encrypt to
2814        the most recent subkey regardless of whether that subkey is
2815        actually an encryption type.  In this case, the auth key is an
2816        RSA key so it succeeds. */
2817
2818     if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
2819       {
2820         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root,
2821                            get_parameter_u32 (para, pKEYEXPIRE), para);
2822         
2823         if (!rc)
2824           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2825         if (!rc)
2826           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2827       }
2828
2829     if( !rc && get_parameter( para, pSUBKEYTYPE ) )
2830       {
2831         if (!card)
2832           {
2833             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2834                             get_parameter_uint( para, pSUBKEYLENGTH ),
2835                             pub_root, sec_root,
2836                             get_parameter_dek( para, pPASSPHRASE_DEK ),
2837                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
2838                             &sub_sk,
2839                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
2840           }
2841         else
2842           {
2843             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
2844               {
2845                 /* A backup of the encryption key has been requested.
2846                    Generate the key i software and import it then to
2847                    the card.  Write a backup file. */
2848                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
2849                                                pub_root, sec_root,
2850                                                get_parameter_u32 (para,
2851                                                                   pKEYEXPIRE),
2852                                                para, s);
2853               }
2854             else
2855               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
2856                                  get_parameter_u32 (para, pKEYEXPIRE), para);
2857           }
2858
2859         if( !rc )
2860           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
2861                                 get_parameter_uint (para, pSUBKEYUSAGE));
2862         if( !rc )
2863           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
2864                                 get_parameter_uint (para, pSUBKEYUSAGE));
2865         did_sub = 1;
2866       }
2867
2868     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2869         rc = write_keyblock( outctrl->pub.stream, pub_root );
2870         if( rc )
2871             log_error("can't write public key: %s\n", g10_errstr(rc) );
2872         if( !rc ) {
2873             rc = write_keyblock( outctrl->sec.stream, sec_root );
2874             if( rc )
2875                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2876         }
2877
2878     }
2879     else if( !rc ) { /* write to the standard keyrings */
2880         KEYDB_HANDLE pub_hd = keydb_new (0);
2881         KEYDB_HANDLE sec_hd = keydb_new (1);
2882
2883         /* FIXME: we may have to create the keyring first */
2884         rc = keydb_locate_writable (pub_hd, NULL);
2885         if (rc) 
2886             log_error (_("no writable public keyring found: %s\n"),
2887                        g10_errstr (rc));
2888
2889         if (!rc) {  
2890             rc = keydb_locate_writable (sec_hd, NULL);
2891             if (rc) 
2892                 log_error (_("no writable secret keyring found: %s\n"),
2893                            g10_errstr (rc));
2894         }
2895
2896         if (!rc && opt.verbose) {
2897             log_info(_("writing public key to `%s'\n"),
2898                      keydb_get_resource_name (pub_hd));
2899             if (card)
2900               log_info (_("writing secret key stub to `%s'\n"),
2901                         keydb_get_resource_name (sec_hd));
2902             else
2903               log_info(_("writing secret key to `%s'\n"),
2904                        keydb_get_resource_name (sec_hd));
2905         }
2906
2907         if (!rc) {
2908             rc = keydb_insert_keyblock (pub_hd, pub_root);
2909             if (rc)
2910                 log_error (_("error writing public keyring `%s': %s\n"),
2911                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2912         }
2913
2914         if (!rc) {
2915             rc = keydb_insert_keyblock (sec_hd, sec_root);
2916             if (rc)
2917                 log_error (_("error writing secret keyring `%s': %s\n"),
2918                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2919         }
2920
2921         keydb_release (pub_hd);
2922         keydb_release (sec_hd);
2923
2924         if (!rc) {
2925             int no_enc_rsa =
2926                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2927                 && get_parameter_uint( para, pKEYUSAGE )
2928                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2929             PKT_public_key *pk = find_kbnode (pub_root, 
2930                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2931
2932             keyid_from_pk(pk,pk->main_keyid);
2933             register_trusted_keyid(pk->main_keyid);
2934
2935             update_ownertrust (pk,
2936                                ((get_ownertrust (pk) & ~TRUST_MASK)
2937                                 | TRUST_ULTIMATE ));
2938
2939             if (!opt.batch) {
2940                 tty_printf(_("public and secret key created and signed.\n") );
2941                 tty_printf("\n");
2942                 list_keyblock(pub_root,0,1,NULL);
2943             }
2944             
2945
2946             if( !opt.batch
2947                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2948                      || no_enc_rsa )
2949                 && !get_parameter( para, pSUBKEYTYPE ) )
2950             {
2951                 tty_printf(_("Note that this key cannot be used for "
2952                              "encryption.  You may want to use\n"
2953                              "the command \"--edit-key\" to generate a "
2954                              "subkey for this purpose.\n") );
2955             }
2956         }
2957     }
2958
2959     if( rc ) {
2960         if( opt.batch )
2961             log_error("key generation failed: %s\n", g10_errstr(rc) );
2962         else
2963             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2964         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
2965     }
2966     else {
2967         PKT_public_key *pk = find_kbnode (pub_root, 
2968                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2969         print_status_key_created (did_sub? 'B':'P', pk,
2970                                   get_parameter_value (para, pHANDLE));
2971     }
2972     release_kbnode( pub_root );
2973     release_kbnode( sec_root );
2974
2975     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
2976       free_secret_key(pri_sk); /* shallow copy in card mode. */
2977     if( sub_sk )
2978         free_secret_key(sub_sk);
2979 }
2980
2981
2982 /****************
2983  * add a new subkey to an existing key.
2984  * Returns true if a new key has been generated and put into the keyblocks.
2985  */
2986 int
2987 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2988 {
2989     int okay=0, rc=0;
2990     KBNODE node;
2991     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2992     int algo;
2993     unsigned int use;
2994     u32 expire;
2995     unsigned nbits;
2996     char *passphrase = NULL;
2997     DEK *dek = NULL;
2998     STRING2KEY *s2k = NULL;
2999     u32 cur_time;
3000     int ask_pass = 0;
3001
3002     /* break out the primary secret key */
3003     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3004     if( !node ) {
3005         log_error("Oops; secret key not found anymore!\n");
3006         goto leave;
3007     }
3008
3009     /* make a copy of the sk to keep the protected one in the keyblock */
3010     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
3011
3012     cur_time = make_timestamp();
3013     if( pri_sk->timestamp > cur_time ) {
3014         ulong d = pri_sk->timestamp - cur_time;
3015         log_info( d==1 ? _("key has been created %lu second "
3016                            "in future (time warp or clock problem)\n")
3017                        : _("key has been created %lu seconds "
3018                            "in future (time warp or clock problem)\n"), d );
3019         if( !opt.ignore_time_conflict ) {
3020             rc = G10ERR_TIME_CONFLICT;
3021             goto leave;
3022         }
3023     }
3024
3025     if (pri_sk->version < 4) {
3026         log_info (_("NOTE: creating subkeys for v3 keys "
3027                     "is not OpenPGP compliant\n"));
3028         goto leave;
3029     }
3030
3031     if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) {
3032         tty_printf(_("Secret parts of primary key are not available.\n"));
3033         rc = G10ERR_NO_SECKEY;
3034         goto leave;
3035     }
3036
3037
3038     /* Unprotect to get the passphrase.  */
3039     switch( is_secret_key_protected( pri_sk ) ) {
3040       case -1:
3041         rc = G10ERR_PUBKEY_ALGO;
3042         break;
3043       case 0:
3044         tty_printf(_("This key is not protected.\n"));
3045         break;
3046       case -2:
3047         tty_printf(_("Secret parts of primary key are stored on-card.\n"));
3048         ask_pass = 1;
3049         break;
3050       default:
3051         tty_printf(_("Key is protected.\n"));
3052         rc = check_secret_key( pri_sk, 0 );
3053         if( !rc )
3054             passphrase = get_last_passphrase();
3055         break;
3056     }
3057     if( rc )
3058         goto leave;
3059
3060     algo = ask_algo( 1, &use );
3061     assert(algo);
3062     nbits = ask_keysize( algo );
3063     expire = ask_expire_interval(0,NULL);
3064     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3065                                                   _("Really create? (y/N) ")))
3066         goto leave;
3067
3068     if (ask_pass)
3069         dek = do_ask_passphrase (&s2k);
3070     else if (passphrase) {
3071         s2k = xmalloc_secure( sizeof *s2k );
3072         s2k->mode = opt.s2k_mode;
3073         s2k->hash_algo = S2K_DIGEST_ALGO;
3074         set_next_passphrase( passphrase );
3075         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3076                                  NULL, NULL );
3077     }
3078
3079     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
3080                                       dek, s2k, &sub_sk, expire, 1 );
3081     if( !rc )
3082         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3083     if( !rc )
3084         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3085     if( !rc ) {
3086         okay = 1;
3087         write_status_text (STATUS_KEY_CREATED, "S");
3088     }
3089
3090   leave:
3091     if( rc )
3092         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3093     xfree( passphrase );
3094     xfree( dek );
3095     xfree( s2k );
3096     /* release the copy of the (now unprotected) secret keys */
3097     if( pri_sk )
3098         free_secret_key(pri_sk);
3099     if( sub_sk )
3100         free_secret_key(sub_sk);
3101     set_next_passphrase( NULL );
3102     return okay;
3103 }
3104
3105
3106 #ifdef ENABLE_CARD_SUPPORT
3107 /* Generate a subkey on a card. */
3108 int
3109 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3110                           int keyno, const char *serialno)
3111 {
3112   int okay=0, rc=0;
3113   KBNODE node;
3114   PKT_secret_key *pri_sk = NULL;
3115   int algo;
3116   unsigned int use;
3117   u32 expire;
3118   char *passphrase = NULL;
3119   u32 cur_time;
3120   struct para_data_s *para = NULL;
3121
3122   assert (keyno >= 1 && keyno <= 3);
3123
3124   para = xcalloc (1, sizeof *para + strlen (serialno) );
3125   para->key = pSERIALNO;
3126   strcpy (para->u.value, serialno);
3127
3128   /* Break out the primary secret key */
3129   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3130   if(!node)
3131     {
3132       log_error("Oops; secret key not found anymore!\n");
3133       goto leave;
3134     }
3135
3136   /* Make a copy of the sk to keep the protected one in the keyblock */
3137   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3138
3139   cur_time = make_timestamp();
3140   if (pri_sk->timestamp > cur_time)
3141     {
3142       ulong d = pri_sk->timestamp - cur_time;
3143       log_info (d==1 ? _("key has been created %lu second "
3144                          "in future (time warp or clock problem)\n")
3145                      : _("key has been created %lu seconds "
3146                          "in future (time warp or clock problem)\n"), d );
3147         if (!opt.ignore_time_conflict)
3148           {
3149             rc = G10ERR_TIME_CONFLICT;
3150             goto leave;
3151           }
3152     }
3153
3154   if (pri_sk->version < 4)
3155     {
3156       log_info (_("NOTE: creating subkeys for v3 keys "
3157                   "is not OpenPGP compliant\n"));
3158       goto leave;
3159     }
3160
3161   /* Unprotect to get the passphrase. */
3162   switch( is_secret_key_protected (pri_sk) )
3163     {
3164     case -1:
3165       rc = G10ERR_PUBKEY_ALGO;
3166       break;
3167     case 0:
3168       tty_printf("This key is not protected.\n");
3169       break;
3170     default:
3171       tty_printf("Key is protected.\n");
3172       rc = check_secret_key( pri_sk, 0 );
3173       if (!rc)
3174         passphrase = get_last_passphrase();
3175       break;
3176     }
3177   if (rc)
3178     goto leave;
3179
3180   algo = PUBKEY_ALGO_RSA;
3181   expire = ask_expire_interval (0,NULL);
3182   if (keyno == 1)
3183     use = PUBKEY_USAGE_SIG;
3184   else if (keyno == 2)
3185     use = PUBKEY_USAGE_ENC;
3186   else
3187     use = PUBKEY_USAGE_AUTH;
3188   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3189                                                _("Really create? (y/N) ")))
3190     goto leave;
3191
3192   if (passphrase)
3193     set_next_passphrase (passphrase);
3194   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock, expire, para);
3195   if (!rc)
3196     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, NULL, use);
3197   if (!rc)
3198     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, NULL, use);
3199   if (!rc)
3200     {
3201       okay = 1;
3202       write_status_text (STATUS_KEY_CREATED, "S");
3203     }
3204
3205  leave:
3206   if (rc)
3207     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3208   xfree (passphrase);
3209   /* Release the copy of the (now unprotected) secret keys. */
3210   if (pri_sk)
3211     free_secret_key (pri_sk);
3212   set_next_passphrase( NULL );
3213   release_parameter_list (para);
3214   return okay;
3215 }
3216 #endif /* !ENABLE_CARD_SUPPORT */
3217
3218
3219 /****************
3220  * Write a keyblock to an output stream
3221  */
3222 static int
3223 write_keyblock( IOBUF out, KBNODE node )
3224 {
3225     for( ; node ; node = node->next ) {
3226         int rc = build_packet( out, node->pkt );
3227         if( rc ) {
3228             log_error("build_packet(%d) failed: %s\n",
3229                         node->pkt->pkttype, g10_errstr(rc) );
3230             return G10ERR_WRITE_FILE;
3231         }
3232     }
3233     return 0;
3234 }
3235
3236
3237 static int
3238 gen_card_key (int algo, int keyno, int is_primary,
3239               KBNODE pub_root, KBNODE sec_root,
3240               u32 expireval, struct para_data_s *para)
3241 {
3242 #ifdef ENABLE_CARD_SUPPORT
3243   int rc;
3244   const char *s;
3245   struct agent_card_genkey_s info;
3246   PACKET *pkt;
3247   PKT_secret_key *sk;
3248   PKT_public_key *pk;
3249
3250   assert (algo == PUBKEY_ALGO_RSA);
3251   
3252
3253   rc = agent_scd_genkey (&info, keyno, 1);
3254 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3255 /*      { */
3256 /*        tty_printf ("\n"); */
3257 /*        log_error ("WARNING: key does already exists!\n"); */
3258 /*        tty_printf ("\n"); */
3259 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3260 /*                                    _("Replace existing key? "))) */
3261 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3262 /*      } */
3263
3264   if (rc)
3265     {
3266       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3267       return rc;
3268     }
3269   if ( !info.n || !info.e )
3270     {
3271       log_error ("communication error with SCD\n");
3272       mpi_free (info.n);
3273       mpi_free (info.e);
3274       return gpg_error (GPG_ERR_GENERAL);
3275     }
3276   
3277
3278   pk = xcalloc (1, sizeof *pk );
3279   sk = xcalloc (1, sizeof *sk );
3280   sk->timestamp = pk->timestamp = info.created_at;
3281   sk->version = pk->version = 4;
3282   if (expireval)
3283       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3284   sk->pubkey_algo = pk->pubkey_algo = algo;
3285   pk->pkey[0] = info.n;
3286   pk->pkey[1] = info.e; 
3287   sk->skey[0] = mpi_copy (pk->pkey[0]);
3288   sk->skey[1] = mpi_copy (pk->pkey[1]);
3289   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3290   sk->is_protected = 1;
3291   sk->protect.s2k.mode = 1002;
3292   s = get_parameter_value (para, pSERIALNO);
3293   if (s)
3294     {
3295       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3296            sk->protect.ivlen++, s += 2)
3297         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3298     }
3299
3300   pkt = xcalloc (1,sizeof *pkt);
3301   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3302   pkt->pkt.public_key = pk;
3303   add_kbnode(pub_root, new_kbnode( pkt ));
3304
3305   pkt = xcalloc (1,sizeof *pkt);
3306   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3307   pkt->pkt.secret_key = sk;
3308   add_kbnode(sec_root, new_kbnode( pkt ));
3309
3310   return 0;
3311 #else
3312   return -1;
3313 #endif /*!ENABLE_CARD_SUPPORT*/
3314 }
3315
3316
3317
3318 static int
3319 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3320                           KBNODE pub_root, KBNODE sec_root,
3321                           u32 expireval, struct para_data_s *para,
3322                           const char *backup_dir)
3323 {
3324 #ifdef ENABLE_CARD_SUPPORT
3325   int rc;
3326   const char *s;
3327   PACKET *pkt;
3328   PKT_secret_key *sk, *sk_unprotected, *sk_protected;
3329   PKT_public_key *pk;
3330   size_t n;
3331   int i;
3332
3333   rc = generate_raw_key (algo, 1024, make_timestamp (),
3334                          &sk_unprotected, &sk_protected);
3335   if (rc)
3336     return rc;
3337
3338   /* First, store the key to the card. */
3339   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3340   if (rc)
3341     {
3342       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3343       free_secret_key (sk_unprotected);
3344       free_secret_key (sk_protected);
3345       return rc;
3346     }
3347
3348   /* Get rid of the secret key parameters and store the serial numer. */
3349   sk = sk_unprotected;
3350   n = pubkey_get_nskey (sk->pubkey_algo);
3351   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3352     {
3353       mpi_free (sk->skey[i]);
3354       sk->skey[i] = NULL;
3355     }
3356   i = pubkey_get_npkey (sk->pubkey_algo);
3357   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3358   sk->is_protected = 1;
3359   sk->protect.s2k.mode = 1002;
3360   s = get_parameter_value (para, pSERIALNO);
3361   assert (s);
3362   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3363        sk->protect.ivlen++, s += 2)
3364     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3365
3366   /* Now write the *protected* secret key to the file.  */
3367   {
3368     char name_buffer[50];
3369     char *fname;
3370     IOBUF fp;
3371     mode_t oldmask;
3372
3373     keyid_from_sk (sk, NULL);
3374     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
3375              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3376
3377     fname = make_filename (backup_dir, name_buffer, NULL);
3378     oldmask = umask (077);
3379     if (is_secured_filename (fname))
3380       {
3381         fp = NULL;
3382         errno = EPERM;
3383       }
3384     else
3385       fp = iobuf_create (fname);
3386     umask (oldmask);
3387     if (!fp) 
3388       {
3389         log_error (_("can't create backup file `%s': %s\n"),
3390                    fname, strerror(errno) );
3391         xfree (fname);
3392         free_secret_key (sk_unprotected);
3393         free_secret_key (sk_protected);
3394         return G10ERR_OPEN_FILE;
3395       }
3396
3397     pkt = xcalloc (1, sizeof *pkt);
3398     pkt->pkttype = PKT_SECRET_KEY;
3399     pkt->pkt.secret_key = sk_protected;
3400     sk_protected = NULL;
3401
3402     rc = build_packet (fp, pkt);
3403     if (rc)
3404       {
3405         log_error("build packet failed: %s\n", g10_errstr(rc) );
3406         iobuf_cancel (fp);
3407       }
3408     else
3409       {
3410         byte array[MAX_FINGERPRINT_LEN];
3411         char *fprbuf, *p;
3412        
3413         iobuf_close (fp);
3414         iobuf_ioctl (NULL, 2, 0, (char*)fname);
3415         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3416
3417         fingerprint_from_sk (sk, array, &n);
3418         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
3419         for (i=0; i < n ; i++, p += 2)
3420           sprintf (p, "%02X", array[i]);
3421         *p++ = ' ';
3422         *p = 0;
3423
3424         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
3425                                       fprbuf,
3426                                       fname, strlen (fname),
3427                                       0);
3428         xfree (fprbuf);
3429       }
3430     free_packet (pkt);
3431     xfree (pkt);
3432     xfree (fname);
3433     if (rc)
3434       {
3435         free_secret_key (sk_unprotected);
3436         return rc;
3437       }
3438   }
3439
3440   /* Create the public key from the secret key. */
3441   pk = xcalloc (1, sizeof *pk );
3442   pk->timestamp = sk->timestamp;
3443   pk->version = sk->version;
3444   if (expireval)
3445       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3446   pk->pubkey_algo = sk->pubkey_algo;
3447   n = pubkey_get_npkey (sk->pubkey_algo);
3448   for (i=0; i < n; i++)
3449     pk->pkey[i] = mpi_copy (sk->skey[i]);
3450
3451   /* Build packets and add them to the node lists.  */
3452   pkt = xcalloc (1,sizeof *pkt);
3453   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3454   pkt->pkt.public_key = pk;
3455   add_kbnode(pub_root, new_kbnode( pkt ));
3456
3457   pkt = xcalloc (1,sizeof *pkt);
3458   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3459   pkt->pkt.secret_key = sk;
3460   add_kbnode(sec_root, new_kbnode( pkt ));
3461
3462   return 0;
3463 #else
3464   return -1;
3465 #endif /*!ENABLE_CARD_SUPPORT*/
3466 }
3467
3468
3469 #ifdef ENABLE_CARD_SUPPORT
3470 int
3471 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3472 {
3473   int rc;
3474   unsigned char *rsa_n = NULL;
3475   unsigned char *rsa_e = NULL;
3476   unsigned char *rsa_p = NULL;
3477   unsigned char *rsa_q = NULL;
3478   unsigned int rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3479   unsigned char *sexp = NULL;
3480   unsigned char *p;
3481   char numbuf[55], numbuf2[50];
3482
3483   assert (is_RSA (sk->pubkey_algo));
3484   assert (!sk->is_protected);
3485
3486   /* Copy the parameters into straight buffers. */
3487   rsa_n = mpi_get_secure_buffer (sk->skey[0], &rsa_n_len, NULL);
3488   rsa_e = mpi_get_secure_buffer (sk->skey[1], &rsa_e_len, NULL);
3489   rsa_p = mpi_get_secure_buffer (sk->skey[3], &rsa_p_len, NULL);
3490   rsa_q = mpi_get_secure_buffer (sk->skey[4], &rsa_q_len, NULL);
3491   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
3492     {
3493       rc = G10ERR_INV_ARG;
3494       goto leave;
3495     }
3496
3497   /* Put the key into an S-expression. */
3498   sexp = p = xmalloc_secure (30
3499                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
3500                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
3501
3502   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
3503   sprintf (numbuf, "%u:", rsa_n_len);
3504   p = stpcpy (p, numbuf);
3505   memcpy (p, rsa_n, rsa_n_len);
3506   p += rsa_n_len;
3507
3508   sprintf (numbuf, ")(1:e%u:", rsa_e_len);
3509   p = stpcpy (p, numbuf);
3510   memcpy (p, rsa_e, rsa_e_len);
3511   p += rsa_e_len;
3512
3513   sprintf (numbuf, ")(1:p%u:", rsa_p_len);
3514   p = stpcpy (p, numbuf);
3515   memcpy (p, rsa_p, rsa_p_len);
3516   p += rsa_p_len;
3517
3518   sprintf (numbuf, ")(1:q%u:", rsa_q_len);
3519   p = stpcpy (p, numbuf);
3520   memcpy (p, rsa_q, rsa_q_len);
3521   p += rsa_q_len;
3522
3523   p = stpcpy (p,"))(10:created-at");
3524   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
3525   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
3526   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
3527
3528   rc = agent_scd_writekey (keyno, sexp, p - sexp);
3529
3530  leave:
3531   xfree (sexp);
3532   xfree (rsa_n);
3533   xfree (rsa_e);
3534   xfree (rsa_p);
3535   xfree (rsa_q);
3536   return rc;
3537 }
3538 #endif /*ENABLE_CARD_SUPPORT*/