0ce588c3722736a3764628b03e8bf25d8e974b3d
[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 if ( !strcmp ( r->u.value, "ELG-E") )
2180         i = GCRY_PK_ELG_E;
2181     else
2182         i = gcry_pk_map_name (r->u.value);
2183     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2184       i = 0; /* we don't want to allow generation of these algorithms */
2185     return i;
2186 }
2187
2188 /* 
2189  * parse the usage parameter and set the keyflags.  Return true on error.
2190  */
2191 static int
2192 parse_parameter_usage (const char *fname,
2193                        struct para_data_s *para, enum para_name key)
2194 {
2195     struct para_data_s *r = get_parameter( para, key );
2196     char *p, *pn;
2197     unsigned int use;
2198
2199     if( !r )
2200         return 0; /* none (this is an optional parameter)*/
2201     
2202     use = 0;
2203     pn = r->u.value;
2204     while ( (p = strsep (&pn, " \t,")) ) {
2205         if ( !*p)
2206             ;
2207         else if ( !ascii_strcasecmp (p, "sign") )
2208             use |= PUBKEY_USAGE_SIG;
2209         else if ( !ascii_strcasecmp (p, "encrypt") )
2210             use |= PUBKEY_USAGE_ENC;
2211         else if ( !ascii_strcasecmp (p, "auth") )
2212             use |= PUBKEY_USAGE_AUTH;
2213         else {
2214             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2215             return -1; /* error */
2216         }
2217     }
2218     r->u.usage = use;
2219     return 1;
2220 }
2221
2222 static int
2223 parse_revocation_key (const char *fname,
2224                       struct para_data_s *para, enum para_name key)
2225 {
2226   struct para_data_s *r = get_parameter( para, key );
2227   struct revocation_key revkey;
2228   char *pn;
2229   int i;
2230
2231   if( !r )
2232     return 0; /* none (this is an optional parameter) */
2233
2234   pn = r->u.value;
2235
2236   revkey.class=0x80;
2237   revkey.algid=atoi(pn);
2238   if(!revkey.algid)
2239     goto fail;
2240
2241   /* Skip to the fpr */
2242   while(*pn && *pn!=':')
2243     pn++;
2244
2245   if(*pn!=':')
2246     goto fail;
2247
2248   pn++;
2249
2250   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2251     {
2252       int c=hextobyte(pn);
2253       if(c==-1)
2254         goto fail;
2255
2256       revkey.fpr[i]=c;
2257     }
2258
2259   /* skip to the tag */
2260   while(*pn && *pn!='s' && *pn!='S')
2261     pn++;
2262
2263   if(ascii_strcasecmp(pn,"sensitive")==0)
2264     revkey.class|=0x40;
2265
2266   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2267
2268   return 0;
2269
2270   fail:
2271   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2272   return -1; /* error */
2273 }
2274
2275
2276 static u32
2277 get_parameter_u32( struct para_data_s *para, enum para_name key )
2278 {
2279     struct para_data_s *r = get_parameter( para, key );
2280
2281     if( !r )
2282         return 0;
2283     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2284         return r->u.expire;
2285     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2286         return r->u.usage;
2287
2288     return (unsigned int)strtoul( r->u.value, NULL, 10 );
2289 }
2290
2291 static unsigned int
2292 get_parameter_uint( struct para_data_s *para, enum para_name key )
2293 {
2294     return get_parameter_u32( para, key );
2295 }
2296
2297 static DEK *
2298 get_parameter_dek( struct para_data_s *para, enum para_name key )
2299 {
2300     struct para_data_s *r = get_parameter( para, key );
2301     return r? r->u.dek : NULL;
2302 }
2303
2304 static STRING2KEY *
2305 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2306 {
2307     struct para_data_s *r = get_parameter( para, key );
2308     return r? r->u.s2k : NULL;
2309 }
2310
2311 static struct revocation_key *
2312 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2313 {
2314     struct para_data_s *r = get_parameter( para, key );
2315     return r? &r->u.revkey : NULL;
2316 }
2317
2318 static int
2319 proc_parameter_file( struct para_data_s *para, const char *fname,
2320                      struct output_control_s *outctrl, int card )
2321 {
2322   struct para_data_s *r;
2323   const char *s1, *s2, *s3;
2324   size_t n;
2325   char *p;
2326   int have_user_id=0,err,algo;
2327
2328   /* Check that we have all required parameters. */
2329   r = get_parameter( para, pKEYTYPE );
2330   if(r)
2331     {
2332       algo=get_parameter_algo(para,pKEYTYPE);
2333       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2334         {
2335           log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2336           return -1;
2337         }
2338     }
2339   else
2340     {
2341       log_error("%s: no Key-Type specified\n",fname);
2342       return -1;
2343     }
2344
2345   err=parse_parameter_usage (fname, para, pKEYUSAGE);
2346   if(err==0)
2347     {
2348       /* Default to algo capabilities if key-usage is not provided */
2349       r=xmalloc_clear(sizeof(*r));
2350       r->key=pKEYUSAGE;
2351       r->u.usage=openpgp_pk_algo_usage(algo);
2352       r->next=para;
2353       para=r;
2354     }
2355   else if(err==-1)
2356     return -1;
2357
2358   r = get_parameter( para, pSUBKEYTYPE );
2359   if(r)
2360     {
2361       algo=get_parameter_algo( para, pSUBKEYTYPE);
2362       if (openpgp_pk_test_algo (algo))
2363         {
2364           log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2365           return -1;
2366         }
2367
2368       err=parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2369       if(err==0)
2370         {
2371           /* Default to algo capabilities if subkey-usage is not
2372              provided */
2373           r=xmalloc_clear(sizeof(*r));
2374           r->key=pSUBKEYUSAGE;
2375           r->u.usage=openpgp_pk_algo_usage(algo);
2376           r->next=para;
2377           para=r;
2378         }
2379       else if(err==-1)
2380         return -1;
2381     }
2382
2383   if( get_parameter_value( para, pUSERID ) )
2384     have_user_id=1;
2385   else
2386     {
2387       /* create the formatted user ID */
2388       s1 = get_parameter_value( para, pNAMEREAL );
2389       s2 = get_parameter_value( para, pNAMECOMMENT );
2390       s3 = get_parameter_value( para, pNAMEEMAIL );
2391       if( s1 || s2 || s3 )
2392         {
2393           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2394           r = xmalloc_clear( sizeof *r + n + 20 );
2395           r->key = pUSERID;
2396           p = r->u.value;
2397           if( s1 )
2398             p = stpcpy(p, s1 );
2399           if( s2 )
2400             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2401           if( s3 )
2402             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2403           r->next = para;
2404           para = r;
2405           have_user_id=1;
2406         }
2407     }
2408
2409   if(!have_user_id)
2410     {
2411       log_error("%s: no User-ID specified\n",fname);
2412       return -1;
2413     }
2414
2415   /* Set preferences, if any. */
2416   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2417
2418   /* Set keyserver, if any. */
2419   s1=get_parameter_value( para, pKEYSERVER );
2420   if(s1)
2421     {
2422       struct keyserver_spec *spec;
2423
2424       spec=parse_keyserver_uri(s1,1,NULL,0);
2425       if(spec)
2426         {
2427           free_keyserver_spec(spec);
2428           opt.def_keyserver_url=s1;
2429         }
2430       else
2431         {
2432           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2433           return -1;
2434         }
2435     }
2436
2437   /* Set revoker, if any. */
2438   if (parse_revocation_key (fname, para, pREVOKER))
2439     return -1;
2440
2441   /* make DEK and S2K from the Passphrase */
2442   r = get_parameter( para, pPASSPHRASE );
2443   if( r && *r->u.value ) {
2444     /* we have a plain text passphrase - create a DEK from it.
2445      * It is a little bit ridiculous to keep it ih secure memory
2446      * but becuase we do this alwasy, why not here */
2447     STRING2KEY *s2k;
2448     DEK *dek;
2449
2450     s2k = xmalloc_secure( sizeof *s2k );
2451     s2k->mode = opt.s2k_mode;
2452     s2k->hash_algo = S2K_DIGEST_ALGO;
2453     set_next_passphrase( r->u.value );
2454     dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2455                              NULL, NULL);
2456     set_next_passphrase( NULL );
2457     assert( dek );
2458     memset( r->u.value, 0, strlen(r->u.value) );
2459
2460     r = xmalloc_clear( sizeof *r );
2461     r->key = pPASSPHRASE_S2K;
2462     r->u.s2k = s2k;
2463     r->next = para;
2464     para = r;
2465     r = xmalloc_clear( sizeof *r );
2466     r->key = pPASSPHRASE_DEK;
2467     r->u.dek = dek;
2468     r->next = para;
2469     para = r;
2470   }
2471
2472   /* make KEYEXPIRE from Expire-Date */
2473   r = get_parameter( para, pEXPIREDATE );
2474   if( r && *r->u.value )
2475     {
2476       u32 seconds;
2477
2478       seconds = parse_expire_string( r->u.value );
2479       if( seconds == (u32)-1 )
2480         {
2481           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2482           return -1;
2483         }
2484       r->u.expire = seconds;
2485       r->key = pKEYEXPIRE;  /* change hat entry */
2486       /* also set it for the subkey */
2487       r = xmalloc_clear( sizeof *r + 20 );
2488       r->key = pSUBKEYEXPIRE;
2489       r->u.expire = seconds;
2490       r->next = para;
2491       para = r;
2492     }
2493
2494   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2495     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2496     return -1;
2497   }
2498
2499   do_generate_keypair( para, outctrl, card );
2500   return 0;
2501 }
2502
2503
2504 /****************
2505  * Kludge to allow non interactive key generation controlled
2506  * by a parameter file.
2507  * Note, that string parameters are expected to be in UTF-8
2508  */
2509 static void
2510 read_parameter_file( const char *fname )
2511 {
2512     static struct { const char *name;
2513                     enum para_name key;
2514     } keywords[] = {
2515         { "Key-Type",       pKEYTYPE},
2516         { "Key-Length",     pKEYLENGTH },
2517         { "Key-Usage",      pKEYUSAGE },
2518         { "Subkey-Type",    pSUBKEYTYPE },
2519         { "Subkey-Length",  pSUBKEYLENGTH },
2520         { "Subkey-Usage",   pSUBKEYUSAGE },
2521         { "Name-Real",      pNAMEREAL },
2522         { "Name-Email",     pNAMEEMAIL },
2523         { "Name-Comment",   pNAMECOMMENT },
2524         { "Expire-Date",    pEXPIREDATE },
2525         { "Passphrase",     pPASSPHRASE },
2526         { "Preferences",    pPREFERENCES },
2527         { "Revoker",        pREVOKER },
2528         { "Handle",         pHANDLE },
2529         { "Keyserver",      pKEYSERVER },
2530         { NULL, 0 }
2531     };
2532     IOBUF fp;
2533     byte *line;
2534     unsigned int maxlen, nline;
2535     char *p;
2536     int lnr;
2537     const char *err = NULL;
2538     struct para_data_s *para, *r;
2539     int i;
2540     struct output_control_s outctrl;
2541
2542     memset( &outctrl, 0, sizeof( outctrl ) );
2543
2544     if( !fname || !*fname)
2545       fname = "-";
2546
2547     fp = iobuf_open (fname);
2548     if (fp && is_secured_file (iobuf_get_fd (fp)))
2549       {
2550         iobuf_close (fp);
2551         fp = NULL;
2552         errno = EPERM;
2553       }
2554     if (!fp) {
2555       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2556       return;
2557     }
2558     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2559
2560     lnr = 0;
2561     err = NULL;
2562     para = NULL;
2563     maxlen = 1024;
2564     line = NULL;
2565     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2566         char *keyword, *value;
2567
2568         lnr++;
2569         if( !maxlen ) {
2570             err = "line too long";
2571             break;
2572         }
2573         for( p = line; isspace(*(byte*)p); p++ )
2574             ;
2575         if( !*p || *p == '#' )
2576             continue;
2577         keyword = p;
2578         if( *keyword == '%' ) {
2579             for( ; !isspace(*(byte*)p); p++ )
2580                 ;
2581             if( *p )
2582                 *p++ = 0;
2583             for( ; isspace(*(byte*)p); p++ )
2584                 ;
2585             value = p;
2586             trim_trailing_ws( value, strlen(value) );
2587             if( !ascii_strcasecmp( keyword, "%echo" ) )
2588                 log_info("%s\n", value );
2589             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2590                 outctrl.dryrun = 1;
2591             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2592                 outctrl.lnr = lnr;
2593                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2594                   print_status_key_not_created 
2595                     (get_parameter_value (para, pHANDLE));
2596                 release_parameter_list( para );
2597                 para = NULL;
2598             }
2599             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2600                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2601                     ; /* still the same file - ignore it */
2602                 else {
2603                     xfree( outctrl.pub.newfname );
2604                     outctrl.pub.newfname = xstrdup( value );
2605                     outctrl.use_files = 1;
2606                 }
2607             }
2608             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2609                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2610                     ; /* still the same file - ignore it */
2611                 else {
2612                    xfree( outctrl.sec.newfname );
2613                    outctrl.sec.newfname = xstrdup( value );
2614                    outctrl.use_files = 1;
2615                 }
2616             }
2617             else
2618                 log_info("skipping control `%s' (%s)\n", keyword, value );
2619
2620
2621             continue;
2622         }
2623
2624
2625         if( !(p = strchr( p, ':' )) || p == keyword ) {
2626             err = "missing colon";
2627             break;
2628         }
2629         if( *p )
2630             *p++ = 0;
2631         for( ; isspace(*(byte*)p); p++ )
2632             ;
2633         if( !*p ) {
2634             err = "missing argument";
2635             break;
2636         }
2637         value = p;
2638         trim_trailing_ws( value, strlen(value) );
2639
2640         for(i=0; keywords[i].name; i++ ) {
2641             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2642                 break;
2643         }
2644         if( !keywords[i].name ) {
2645             err = "unknown keyword";
2646             break;
2647         }
2648         if( keywords[i].key != pKEYTYPE && !para ) {
2649             err = "parameter block does not start with \"Key-Type\"";
2650             break;
2651         }
2652
2653         if( keywords[i].key == pKEYTYPE && para ) {
2654             outctrl.lnr = lnr;
2655             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2656               print_status_key_not_created
2657                 (get_parameter_value (para, pHANDLE));
2658             release_parameter_list( para );
2659             para = NULL;
2660         }
2661         else {
2662             for( r = para; r; r = r->next ) {
2663                 if( r->key == keywords[i].key )
2664                     break;
2665             }
2666             if( r ) {
2667                 err = "duplicate keyword";
2668                 break;
2669             }
2670         }
2671         r = xmalloc_clear( sizeof *r + strlen( value ) );
2672         r->lnr = lnr;
2673         r->key = keywords[i].key;
2674         strcpy( r->u.value, value );
2675         r->next = para;
2676         para = r;
2677     }
2678     if( err )
2679         log_error("%s:%d: %s\n", fname, lnr, err );
2680     else if( iobuf_error (fp) ) {
2681         log_error("%s:%d: read error\n", fname, lnr);
2682     }
2683     else if( para ) {
2684         outctrl.lnr = lnr;
2685         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2686           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2687     }
2688
2689     if( outctrl.use_files ) { /* close open streams */
2690         iobuf_close( outctrl.pub.stream );
2691         iobuf_close( outctrl.sec.stream );
2692
2693         /* Must invalidate that ugly cache to actually close it.  */
2694         if (outctrl.pub.fname)
2695           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2696         if (outctrl.sec.fname)
2697           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2698
2699         xfree( outctrl.pub.fname );
2700         xfree( outctrl.pub.newfname );
2701         xfree( outctrl.sec.fname );
2702         xfree( outctrl.sec.newfname );
2703     }
2704
2705     release_parameter_list( para );
2706     iobuf_close (fp);
2707 }
2708
2709
2710 /*
2711  * Generate a keypair (fname is only used in batch mode) If
2712  * CARD_SERIALNO is not NULL the function will create the keys on an
2713  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2714  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2715  * generate in software, imported to the card and a backup file
2716  * written to directory given by this argument .
2717  */
2718 void
2719 generate_keypair (const char *fname, const char *card_serialno, 
2720                   const char *backup_encryption_dir)
2721 {
2722   unsigned int nbits;
2723   char *uid = NULL;
2724   DEK *dek;
2725   STRING2KEY *s2k;
2726   int algo;
2727   unsigned int use;
2728   int both = 0;
2729   u32 expire;
2730   struct para_data_s *para = NULL;
2731   struct para_data_s *r;
2732   struct output_control_s outctrl;
2733   
2734   memset( &outctrl, 0, sizeof( outctrl ) );
2735   
2736   if (opt.batch && card_serialno)
2737     {
2738       /* We don't yet support unattended key generation. */
2739       log_error (_("can't do this in batch mode\n"));
2740       return;
2741     }
2742   
2743   if (opt.batch)
2744     {
2745       read_parameter_file( fname );
2746       return;
2747     }
2748
2749   if (card_serialno)
2750     {
2751 #ifdef ENABLE_CARD_SUPPORT
2752       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2753       r->key = pSERIALNO;
2754       strcpy( r->u.value, card_serialno);
2755       r->next = para;
2756       para = r;
2757        
2758       algo = PUBKEY_ALGO_RSA;
2759        
2760       r = xcalloc (1, sizeof *r + 20 );
2761       r->key = pKEYTYPE;
2762       sprintf( r->u.value, "%d", algo );
2763       r->next = para;
2764       para = r;
2765       r = xcalloc (1, sizeof *r + 20 );
2766       r->key = pKEYUSAGE;
2767       strcpy (r->u.value, "sign");
2768       r->next = para;
2769       para = r;
2770        
2771       r = xcalloc (1, sizeof *r + 20 );
2772       r->key = pSUBKEYTYPE;
2773       sprintf( r->u.value, "%d", algo );
2774       r->next = para;
2775       para = r;
2776       r = xcalloc (1, sizeof *r + 20 );
2777       r->key = pSUBKEYUSAGE;
2778       strcpy (r->u.value, "encrypt");
2779       r->next = para;
2780       para = r;
2781        
2782       r = xcalloc (1, sizeof *r + 20 );
2783       r->key = pAUTHKEYTYPE;
2784       sprintf( r->u.value, "%d", algo );
2785       r->next = para;
2786       para = r;
2787
2788       if (backup_encryption_dir)
2789         {
2790           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2791           r->key = pBACKUPENCDIR;
2792           strcpy (r->u.value, backup_encryption_dir);
2793           r->next = para;
2794           para = r;
2795         }
2796 #endif /*ENABLE_CARD_SUPPORT*/
2797     }
2798   else
2799     {
2800       algo = ask_algo( 0, &use );
2801       if( !algo )
2802         { /* default: DSA with ElG subkey of the specified size */
2803           both = 1;
2804           r = xmalloc_clear( sizeof *r + 20 );
2805           r->key = pKEYTYPE;
2806           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2807           r->next = para;
2808           para = r;
2809           nbits = ask_keysize( PUBKEY_ALGO_DSA );
2810           r = xmalloc_clear( sizeof *r + 20 );
2811           r->key = pKEYLENGTH;
2812           sprintf( r->u.value, "%u", nbits);
2813           r->next = para;
2814           para = r;
2815           r = xmalloc_clear( sizeof *r + 20 );
2816           r->key = pKEYUSAGE;
2817           strcpy( r->u.value, "sign" );
2818           r->next = para;
2819           para = r;
2820            
2821           algo = PUBKEY_ALGO_ELGAMAL_E;
2822           r = xmalloc_clear( sizeof *r + 20 );
2823           r->key = pSUBKEYTYPE;
2824           sprintf( r->u.value, "%d", algo );
2825           r->next = para;
2826           para = r;
2827           r = xmalloc_clear( sizeof *r + 20 );
2828           r->key = pSUBKEYUSAGE;
2829           strcpy( r->u.value, "encrypt" );
2830           r->next = para;
2831           para = r;
2832         }
2833       else 
2834         {
2835           r = xmalloc_clear( sizeof *r + 20 );
2836           r->key = pKEYTYPE;
2837           sprintf( r->u.value, "%d", algo );
2838           r->next = para;
2839           para = r;
2840            
2841           if (use)
2842             {
2843               r = xmalloc_clear( sizeof *r + 25 );
2844               r->key = pKEYUSAGE;
2845               sprintf( r->u.value, "%s%s%s",
2846                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2847                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
2848                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
2849               r->next = para;
2850               para = r;
2851             }
2852            
2853         }
2854
2855       nbits = ask_keysize( algo );
2856       r = xmalloc_clear( sizeof *r + 20 );
2857       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2858       sprintf( r->u.value, "%u", nbits);
2859       r->next = para;
2860       para = r;
2861     }
2862    
2863   expire = ask_expire_interval(0,NULL);
2864   r = xmalloc_clear( sizeof *r + 20 );
2865   r->key = pKEYEXPIRE;
2866   r->u.expire = expire;
2867   r->next = para;
2868   para = r;
2869   r = xmalloc_clear( sizeof *r + 20 );
2870   r->key = pSUBKEYEXPIRE;
2871   r->u.expire = expire;
2872   r->next = para;
2873   para = r;
2874
2875   uid = ask_user_id(0);
2876   if( !uid ) 
2877     {
2878       log_error(_("Key generation canceled.\n"));
2879       release_parameter_list( para );
2880       return;
2881     }
2882   r = xmalloc_clear( sizeof *r + strlen(uid) );
2883   r->key = pUSERID;
2884   strcpy( r->u.value, uid );
2885   r->next = para;
2886   para = r;
2887     
2888   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2889   if( dek )
2890     {
2891       r = xmalloc_clear( sizeof *r );
2892       r->key = pPASSPHRASE_DEK;
2893       r->u.dek = dek;
2894       r->next = para;
2895       para = r;
2896       r = xmalloc_clear( sizeof *r );
2897       r->key = pPASSPHRASE_S2K;
2898       r->u.s2k = s2k;
2899       r->next = para;
2900       para = r;
2901     }
2902     
2903   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2904   release_parameter_list( para );
2905 }
2906
2907
2908 #ifdef ENABLE_CARD_SUPPORT
2909 /* Generate a raw key and return it as a secret key packet.  The
2910    function will ask for the passphrase and return a protected as well
2911    as an unprotected copy of a new secret key packet.  0 is returned
2912    on success and the caller must then free the returned values.  */
2913 static int
2914 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
2915                   PKT_secret_key **r_sk_unprotected,
2916                   PKT_secret_key **r_sk_protected)
2917 {
2918   int rc;
2919   DEK *dek = NULL;
2920   STRING2KEY *s2k = NULL;
2921   PKT_secret_key *sk = NULL;
2922   int i;
2923   size_t nskey, npkey;
2924   gcry_sexp_t s_parms, s_key;
2925
2926   npkey = pubkey_get_npkey (algo);
2927   nskey = pubkey_get_nskey (algo);
2928   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
2929
2930   if (nbits < 512)
2931     {
2932       nbits = 512;
2933       log_info (_("keysize invalid; using %u bits\n"), nbits );
2934     }
2935
2936   if ((nbits % 32)) 
2937     {
2938       nbits = ((nbits + 31) / 32) * 32;
2939       log_info(_("keysize rounded up to %u bits\n"), nbits );
2940     }
2941
2942   dek = do_ask_passphrase (&s2k);
2943
2944   sk = xmalloc_clear (sizeof *sk);
2945   sk->timestamp = created_at;
2946   sk->version = 4;
2947   sk->pubkey_algo = algo;
2948
2949   if ( !is_RSA (algo) )
2950     {
2951       log_error ("only RSA is supported for offline generated keys\n");
2952       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2953       goto leave;
2954     }
2955   rc = gcry_sexp_build (&s_parms, NULL,
2956                         "(genkey(rsa(nbits %d)))",
2957                         (int)nbits);
2958   if (rc)
2959     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
2960   rc = gcry_pk_genkey (&s_key, s_parms);
2961   gcry_sexp_release (s_parms);
2962   if (rc)
2963     {
2964       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
2965       goto leave;
2966     }
2967   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
2968   gcry_sexp_release (s_key);
2969   if (rc) 
2970     {
2971       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
2972       goto leave;
2973     }
2974   
2975   for (i=npkey; i < nskey; i++)
2976     sk->csum += checksum_mpi (sk->skey[i]);
2977
2978   if (r_sk_unprotected) 
2979     *r_sk_unprotected = copy_secret_key (NULL, sk);
2980
2981   rc = genhelp_protect (dek, s2k, sk);
2982   if (rc)
2983     goto leave;
2984
2985   if (r_sk_protected)
2986     {
2987       *r_sk_protected = sk;
2988       sk = NULL;
2989     }
2990
2991  leave:
2992   if (sk)
2993     free_secret_key (sk);
2994   xfree (dek);
2995   xfree (s2k);
2996   return rc;
2997 }
2998 #endif /* ENABLE_CARD_SUPPORT */
2999
3000 /* Create and delete a dummy packet to start off a list of kbnodes. */
3001 static void
3002 start_tree(KBNODE *tree)
3003 {
3004   PACKET *pkt;
3005
3006   pkt=xmalloc_clear(sizeof(*pkt));
3007   pkt->pkttype=PKT_NONE;
3008   *tree=new_kbnode(pkt);
3009   delete_kbnode(*tree);
3010 }
3011
3012 static void
3013 do_generate_keypair( struct para_data_s *para,
3014                      struct output_control_s *outctrl, int card )
3015 {
3016     KBNODE pub_root = NULL;
3017     KBNODE sec_root = NULL;
3018     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3019     const char *s;
3020     struct revocation_key *revkey;
3021     int rc;
3022     int did_sub = 0;
3023
3024     if( outctrl->dryrun )
3025       {
3026         log_info("dry-run mode - key generation skipped\n");
3027         return;
3028       }
3029
3030     if( outctrl->use_files ) {
3031         if( outctrl->pub.newfname ) {
3032             iobuf_close(outctrl->pub.stream);
3033             outctrl->pub.stream = NULL;
3034             if (outctrl->pub.fname)
3035               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
3036             xfree( outctrl->pub.fname );
3037             outctrl->pub.fname =  outctrl->pub.newfname;
3038             outctrl->pub.newfname = NULL;
3039
3040             if (is_secured_filename (outctrl->pub.fname) ) {
3041                 outctrl->pub.stream = NULL;
3042                 errno = EPERM;
3043             }
3044             else
3045                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3046             if( !outctrl->pub.stream ) {
3047                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3048                                                      strerror(errno) );
3049                 return;
3050             }
3051             if( opt.armor ) {
3052                 outctrl->pub.afx.what = 1;
3053                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
3054                                                     &outctrl->pub.afx );
3055             }
3056         }
3057         if( outctrl->sec.newfname ) {
3058             mode_t oldmask;
3059
3060             iobuf_close(outctrl->sec.stream);
3061             outctrl->sec.stream = NULL;
3062             if (outctrl->sec.fname)
3063               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3064             xfree( outctrl->sec.fname );
3065             outctrl->sec.fname =  outctrl->sec.newfname;
3066             outctrl->sec.newfname = NULL;
3067
3068             oldmask = umask (077);
3069             if (is_secured_filename (outctrl->sec.fname) ) {
3070                 outctrl->sec.stream = NULL;
3071                 errno = EPERM;
3072             }
3073             else
3074                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3075             umask (oldmask);
3076             if( !outctrl->sec.stream ) {
3077                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3078                                                      strerror(errno) );
3079                 return;
3080             }
3081             if( opt.armor ) {
3082                 outctrl->sec.afx.what = 5;
3083                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
3084                                                     &outctrl->sec.afx );
3085             }
3086         }
3087         assert( outctrl->pub.stream );
3088         assert( outctrl->sec.stream );
3089         if( opt.verbose ) {
3090             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
3091             if (card)
3092               log_info (_("writing secret key stub to `%s'\n"),
3093                         outctrl->sec.fname);
3094             else
3095               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3096         }
3097     }
3098
3099
3100     /* we create the packets as a tree of kbnodes. Because the
3101      * structure we create is known in advance we simply generate a
3102      * linked list.  The first packet is a dummy packet which we flag
3103      * as deleted.  The very first packet must always be a KEY packet.
3104      */
3105     
3106     start_tree(&pub_root);
3107     start_tree(&sec_root);
3108
3109     if (!card)
3110       {
3111         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
3112                         get_parameter_uint( para, pKEYLENGTH ),
3113                         pub_root, sec_root,
3114                         get_parameter_dek( para, pPASSPHRASE_DEK ),
3115                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
3116                         &pri_sk,
3117                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
3118       }
3119     else
3120       {
3121         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root, NULL,
3122                            get_parameter_u32 (para, pKEYEXPIRE), para);
3123         if (!rc)
3124           {
3125             pri_sk = sec_root->next->pkt->pkt.secret_key;
3126             assert (pri_sk);
3127           }
3128       }
3129
3130     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3131       {
3132         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
3133         if(!rc)
3134           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
3135       }
3136
3137     if( !rc && (s=get_parameter_value(para, pUSERID)) )
3138       {
3139         write_uid(pub_root, s );
3140         if( !rc )
3141           write_uid(sec_root, s );
3142
3143         if( !rc )
3144           rc = write_selfsigs(sec_root, pub_root, pri_sk,
3145                               get_parameter_uint (para, pKEYUSAGE));
3146       }
3147
3148     /* Write the auth key to the card before the encryption key.  This
3149        is a partial workaround for a PGP bug (as of this writing, all
3150        versions including 8.1), that causes it to try and encrypt to
3151        the most recent subkey regardless of whether that subkey is
3152        actually an encryption type.  In this case, the auth key is an
3153        RSA key so it succeeds. */
3154
3155     if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3156       {
3157         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root, NULL,
3158                            get_parameter_u32 (para, pKEYEXPIRE), para);
3159         
3160         if (!rc)
3161           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
3162         if (!rc)
3163           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
3164       }
3165
3166     if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3167       {
3168         if (!card)
3169           {
3170             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
3171                             get_parameter_uint( para, pSUBKEYLENGTH ),
3172                             pub_root, sec_root,
3173                             get_parameter_dek( para, pPASSPHRASE_DEK ),
3174                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
3175                             &sub_sk,
3176                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3177           }
3178         else
3179           {
3180             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3181               {
3182                 /* A backup of the encryption key has been requested.
3183                    Generate the key i software and import it then to
3184                    the card.  Write a backup file. */
3185                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3186                                                pub_root, sec_root,
3187                                                get_parameter_u32 (para,
3188                                                                   pKEYEXPIRE),
3189                                                para, s);
3190               }
3191             else
3192               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3193                                  NULL,
3194                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3195           }
3196
3197         if( !rc )
3198           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
3199                                 get_parameter_uint (para, pSUBKEYUSAGE));
3200         if( !rc )
3201           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
3202                                 get_parameter_uint (para, pSUBKEYUSAGE));
3203         did_sub = 1;
3204       }
3205
3206     if( !rc && outctrl->use_files ) { /* direct write to specified files */
3207         rc = write_keyblock( outctrl->pub.stream, pub_root );
3208         if( rc )
3209             log_error("can't write public key: %s\n", g10_errstr(rc) );
3210         if( !rc ) {
3211             rc = write_keyblock( outctrl->sec.stream, sec_root );
3212             if( rc )
3213                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
3214         }
3215
3216     }
3217     else if( !rc ) { /* write to the standard keyrings */
3218         KEYDB_HANDLE pub_hd = keydb_new (0);
3219         KEYDB_HANDLE sec_hd = keydb_new (1);
3220
3221         /* FIXME: we may have to create the keyring first */
3222         rc = keydb_locate_writable (pub_hd, NULL);
3223         if (rc) 
3224             log_error (_("no writable public keyring found: %s\n"),
3225                        g10_errstr (rc));
3226
3227         if (!rc) {  
3228             rc = keydb_locate_writable (sec_hd, NULL);
3229             if (rc) 
3230                 log_error (_("no writable secret keyring found: %s\n"),
3231                            g10_errstr (rc));
3232         }
3233
3234         if (!rc && opt.verbose) {
3235             log_info(_("writing public key to `%s'\n"),
3236                      keydb_get_resource_name (pub_hd));
3237             if (card)
3238               log_info (_("writing secret key stub to `%s'\n"),
3239                         keydb_get_resource_name (sec_hd));
3240             else
3241               log_info(_("writing secret key to `%s'\n"),
3242                        keydb_get_resource_name (sec_hd));
3243         }
3244
3245         if (!rc) {
3246             rc = keydb_insert_keyblock (pub_hd, pub_root);
3247             if (rc)
3248                 log_error (_("error writing public keyring `%s': %s\n"),
3249                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
3250         }
3251
3252         if (!rc) {
3253             rc = keydb_insert_keyblock (sec_hd, sec_root);
3254             if (rc)
3255                 log_error (_("error writing secret keyring `%s': %s\n"),
3256                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
3257         }
3258
3259         keydb_release (pub_hd);
3260         keydb_release (sec_hd);
3261
3262         if (!rc) {
3263             int no_enc_rsa =
3264                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
3265                 && get_parameter_uint( para, pKEYUSAGE )
3266                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
3267             PKT_public_key *pk = find_kbnode (pub_root, 
3268                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3269
3270             keyid_from_pk(pk,pk->main_keyid);
3271             register_trusted_keyid(pk->main_keyid);
3272
3273             update_ownertrust (pk,
3274                                ((get_ownertrust (pk) & ~TRUST_MASK)
3275                                 | TRUST_ULTIMATE ));
3276
3277             if (!opt.batch) {
3278                 tty_printf(_("public and secret key created and signed.\n") );
3279                 tty_printf("\n");
3280                 list_keyblock(pub_root,0,1,NULL);
3281             }
3282             
3283
3284             if( !opt.batch
3285                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
3286                      || no_enc_rsa )
3287                 && !get_parameter( para, pSUBKEYTYPE ) )
3288             {
3289                 tty_printf(_("Note that this key cannot be used for "
3290                              "encryption.  You may want to use\n"
3291                              "the command \"--edit-key\" to generate a "
3292                              "subkey for this purpose.\n") );
3293             }
3294         }
3295     }
3296
3297     if( rc ) {
3298         if( opt.batch )
3299             log_error("key generation failed: %s\n", g10_errstr(rc) );
3300         else
3301             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
3302         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3303     }
3304     else {
3305         PKT_public_key *pk = find_kbnode (pub_root, 
3306                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3307         print_status_key_created (did_sub? 'B':'P', pk,
3308                                   get_parameter_value (para, pHANDLE));
3309     }
3310     release_kbnode( pub_root );
3311     release_kbnode( sec_root );
3312
3313     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
3314       free_secret_key(pri_sk); /* shallow copy in card mode. */
3315     if( sub_sk )
3316         free_secret_key(sub_sk);
3317 }
3318
3319
3320 /****************
3321  * add a new subkey to an existing key.
3322  * Returns true if a new key has been generated and put into the keyblocks.
3323  */
3324 int
3325 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
3326 {
3327     int okay=0, rc=0;
3328     KBNODE node;
3329     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3330     int algo;
3331     unsigned int use;
3332     u32 expire;
3333     unsigned nbits;
3334     char *passphrase = NULL;
3335     DEK *dek = NULL;
3336     STRING2KEY *s2k = NULL;
3337     u32 cur_time;
3338     int ask_pass = 0;
3339
3340     /* break out the primary secret key */
3341     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3342     if( !node ) {
3343         log_error("Oops; secret key not found anymore!\n");
3344         goto leave;
3345     }
3346
3347     /* make a copy of the sk to keep the protected one in the keyblock */
3348     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
3349
3350     cur_time = make_timestamp();
3351     if( pri_sk->timestamp > cur_time ) {
3352         ulong d = pri_sk->timestamp - cur_time;
3353         log_info( d==1 ? _("key has been created %lu second "
3354                            "in future (time warp or clock problem)\n")
3355                        : _("key has been created %lu seconds "
3356                            "in future (time warp or clock problem)\n"), d );
3357         if( !opt.ignore_time_conflict ) {
3358             rc = G10ERR_TIME_CONFLICT;
3359             goto leave;
3360         }
3361     }
3362
3363     if (pri_sk->version < 4) {
3364         log_info (_("NOTE: creating subkeys for v3 keys "
3365                     "is not OpenPGP compliant\n"));
3366         goto leave;
3367     }
3368
3369     if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) {
3370         tty_printf(_("Secret parts of primary key are not available.\n"));
3371         rc = G10ERR_NO_SECKEY;
3372         goto leave;
3373     }
3374
3375
3376     /* Unprotect to get the passphrase.  */
3377     switch( is_secret_key_protected( pri_sk ) ) {
3378       case -1:
3379         rc = G10ERR_PUBKEY_ALGO;
3380         break;
3381       case 0:
3382         tty_printf(_("This key is not protected.\n"));
3383         break;
3384       case -2:
3385         tty_printf(_("Secret parts of primary key are stored on-card.\n"));
3386         ask_pass = 1;
3387         break;
3388       default:
3389         tty_printf(_("Key is protected.\n"));
3390         rc = check_secret_key( pri_sk, 0 );
3391         if( !rc )
3392             passphrase = get_last_passphrase();
3393         break;
3394     }
3395     if( rc )
3396         goto leave;
3397
3398     algo = ask_algo( 1, &use );
3399     assert(algo);
3400     nbits = ask_keysize( algo );
3401     expire = ask_expire_interval(0,NULL);
3402     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3403                                                   _("Really create? (y/N) ")))
3404         goto leave;
3405
3406     if (ask_pass)
3407         dek = do_ask_passphrase (&s2k);
3408     else if (passphrase) {
3409         s2k = xmalloc_secure( sizeof *s2k );
3410         s2k->mode = opt.s2k_mode;
3411         s2k->hash_algo = S2K_DIGEST_ALGO;
3412         set_next_passphrase( passphrase );
3413         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3414                                  NULL, NULL );
3415     }
3416
3417     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
3418                     dek, s2k, &sub_sk, expire, 1 );
3419     if( !rc )
3420         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3421     if( !rc )
3422         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3423     if( !rc ) {
3424         okay = 1;
3425         write_status_text (STATUS_KEY_CREATED, "S");
3426     }
3427
3428   leave:
3429     if( rc )
3430         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3431     xfree( passphrase );
3432     xfree( dek );
3433     xfree( s2k );
3434     /* release the copy of the (now unprotected) secret keys */
3435     if( pri_sk )
3436         free_secret_key(pri_sk);
3437     if( sub_sk )
3438         free_secret_key(sub_sk);
3439     set_next_passphrase( NULL );
3440     return okay;
3441 }
3442
3443
3444 #ifdef ENABLE_CARD_SUPPORT
3445 /* Generate a subkey on a card. */
3446 int
3447 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3448                           int keyno, const char *serialno)
3449 {
3450   int okay=0, rc=0;
3451   KBNODE node;
3452   PKT_secret_key *pri_sk = NULL, *sub_sk;
3453   int algo;
3454   unsigned int use;
3455   u32 expire;
3456   char *passphrase = NULL;
3457   u32 cur_time;
3458   struct para_data_s *para = NULL;
3459
3460   assert (keyno >= 1 && keyno <= 3);
3461
3462   para = xcalloc (1, sizeof *para + strlen (serialno) );
3463   para->key = pSERIALNO;
3464   strcpy (para->u.value, serialno);
3465
3466   /* Break out the primary secret key */
3467   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3468   if(!node)
3469     {
3470       log_error("Oops; secret key not found anymore!\n");
3471       goto leave;
3472     }
3473
3474   /* Make a copy of the sk to keep the protected one in the keyblock */
3475   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3476
3477   cur_time = make_timestamp();
3478   if (pri_sk->timestamp > cur_time)
3479     {
3480       ulong d = pri_sk->timestamp - cur_time;
3481       log_info (d==1 ? _("key has been created %lu second "
3482                          "in future (time warp or clock problem)\n")
3483                      : _("key has been created %lu seconds "
3484                          "in future (time warp or clock problem)\n"), d );
3485         if (!opt.ignore_time_conflict)
3486           {
3487             rc = G10ERR_TIME_CONFLICT;
3488             goto leave;
3489           }
3490     }
3491
3492   if (pri_sk->version < 4)
3493     {
3494       log_info (_("NOTE: creating subkeys for v3 keys "
3495                   "is not OpenPGP compliant\n"));
3496       goto leave;
3497     }
3498
3499   /* Unprotect to get the passphrase. */
3500   switch( is_secret_key_protected (pri_sk) )
3501     {
3502     case -1:
3503       rc = G10ERR_PUBKEY_ALGO;
3504       break;
3505     case 0:
3506       tty_printf("This key is not protected.\n");
3507       break;
3508     default:
3509       tty_printf("Key is protected.\n");
3510       rc = check_secret_key( pri_sk, 0 );
3511       if (!rc)
3512         passphrase = get_last_passphrase();
3513       break;
3514     }
3515   if (rc)
3516     goto leave;
3517
3518   algo = PUBKEY_ALGO_RSA;
3519   expire = ask_expire_interval (0,NULL);
3520   if (keyno == 1)
3521     use = PUBKEY_USAGE_SIG;
3522   else if (keyno == 2)
3523     use = PUBKEY_USAGE_ENC;
3524   else
3525     use = PUBKEY_USAGE_AUTH;
3526   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3527                                                _("Really create? (y/N) ")))
3528     goto leave;
3529
3530   if (passphrase)
3531     set_next_passphrase (passphrase);
3532   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock,
3533                      &sub_sk, expire, para);
3534   if (!rc)
3535     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3536   if (!rc)
3537     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3538   if (!rc)
3539     {
3540       okay = 1;
3541       write_status_text (STATUS_KEY_CREATED, "S");
3542     }
3543
3544  leave:
3545   if (rc)
3546     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3547   xfree (passphrase);
3548   /* Release the copy of the (now unprotected) secret keys. */
3549   if (pri_sk)
3550     free_secret_key (pri_sk);
3551   set_next_passphrase( NULL );
3552   release_parameter_list (para);
3553   return okay;
3554 }
3555 #endif /* !ENABLE_CARD_SUPPORT */
3556
3557
3558 /****************
3559  * Write a keyblock to an output stream
3560  */
3561 static int
3562 write_keyblock( IOBUF out, KBNODE node )
3563 {
3564   for( ; node ; node = node->next )
3565     {
3566       if(!is_deleted_kbnode(node))
3567         {
3568           int rc = build_packet( out, node->pkt );
3569           if( rc )
3570             {
3571               log_error("build_packet(%d) failed: %s\n",
3572                         node->pkt->pkttype, g10_errstr(rc) );
3573               return rc;
3574             }
3575         }
3576     }
3577
3578   return 0;
3579 }
3580
3581
3582 static int
3583 gen_card_key (int algo, int keyno, int is_primary,
3584               KBNODE pub_root, KBNODE sec_root, PKT_secret_key **ret_sk,
3585               u32 expireval, struct para_data_s *para)
3586 {
3587 #ifdef ENABLE_CARD_SUPPORT
3588   int rc;
3589   const char *s;
3590   struct agent_card_genkey_s info;
3591   PACKET *pkt;
3592   PKT_secret_key *sk;
3593   PKT_public_key *pk;
3594
3595   assert (algo == PUBKEY_ALGO_RSA);
3596   
3597   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
3598   rc = agent_scd_genkey (&info, keyno, 1, NULL);
3599 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3600 /*      { */
3601 /*        tty_printf ("\n"); */
3602 /*        log_error ("WARNING: key does already exists!\n"); */
3603 /*        tty_printf ("\n"); */
3604 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3605 /*                                    _("Replace existing key? "))) */
3606 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3607 /*      } */
3608
3609   if (rc)
3610     {
3611       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3612       return rc;
3613     }
3614   if ( !info.n || !info.e )
3615     {
3616       log_error ("communication error with SCD\n");
3617       gcry_mpi_release (info.n);
3618       gcry_mpi_release (info.e);
3619       return gpg_error (GPG_ERR_GENERAL);
3620     }
3621   
3622
3623   pk = xcalloc (1, sizeof *pk );
3624   sk = xcalloc (1, sizeof *sk );
3625   sk->timestamp = pk->timestamp = info.created_at;
3626   sk->version = pk->version = 4;
3627   if (expireval)
3628       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3629   sk->pubkey_algo = pk->pubkey_algo = algo;
3630   pk->pkey[0] = info.n;
3631   pk->pkey[1] = info.e; 
3632   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
3633   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
3634   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3635   sk->is_protected = 1;
3636   sk->protect.s2k.mode = 1002;
3637   s = get_parameter_value (para, pSERIALNO);