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