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