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