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