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