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