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