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