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