Print keyid in gpg --list-packets.
[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 || (!opt.flags.dsa2 && nbits > 1024)) 
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) != 7 )
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 /****************
1640  * Returns: 0 to create both a DSA and a Elgamal key.
1641  *          and only if key flags are to be written the desired usage.
1642  */
1643 static int
1644 ask_algo (int addmode, unsigned int *r_usage)
1645 {
1646     char *answer;
1647     int algo;
1648
1649     *r_usage = 0;
1650     tty_printf(_("Please select what kind of key you want:\n"));
1651     if( !addmode )
1652         tty_printf(_("   (%d) DSA and Elgamal (default)\n"), 1 );
1653     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
1654     if (opt.expert)
1655       tty_printf(  _("   (%d) DSA (set your own capabilities)\n"), 3 );
1656     if( addmode )
1657         tty_printf(_("   (%d) Elgamal (encrypt only)\n"), 4 );
1658     tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
1659     if (addmode)
1660         tty_printf(_("   (%d) RSA (encrypt only)\n"), 6 );
1661     if (opt.expert)
1662       tty_printf(  _("   (%d) RSA (set your own capabilities)\n"), 7 );
1663
1664     for(;;) {
1665         answer = cpr_get("keygen.algo",_("Your selection? "));
1666         cpr_kill_prompt();
1667         algo = *answer? atoi(answer): 1;
1668         xfree(answer);
1669         if( algo == 1 && !addmode ) {
1670             algo = 0;   /* create both keys */
1671             break;
1672         }
1673         else if( algo == 7 && opt.expert ) {
1674             algo = PUBKEY_ALGO_RSA;
1675             *r_usage=ask_key_flags(algo,addmode);
1676             break;
1677         }
1678         else if( algo == 6 && addmode ) {
1679             algo = PUBKEY_ALGO_RSA;
1680             *r_usage = PUBKEY_USAGE_ENC;
1681             break;
1682         }
1683         else if( algo == 5 ) {
1684             algo = PUBKEY_ALGO_RSA;
1685             *r_usage = PUBKEY_USAGE_SIG;
1686             break;
1687         }
1688         else if( algo == 4 && addmode ) {
1689             algo = PUBKEY_ALGO_ELGAMAL_E;
1690             *r_usage = PUBKEY_USAGE_ENC;
1691             break;
1692         }
1693         else if( algo == 3 && opt.expert ) {
1694             algo = PUBKEY_ALGO_DSA;
1695             *r_usage=ask_key_flags(algo,addmode);
1696             break;
1697         }
1698         else if( algo == 2 ) {
1699             algo = PUBKEY_ALGO_DSA;
1700             *r_usage = PUBKEY_USAGE_SIG;
1701             break;
1702         }
1703         else
1704             tty_printf(_("Invalid selection.\n"));
1705     }
1706
1707     return algo;
1708 }
1709
1710
1711 static unsigned
1712 ask_keysize( int algo )
1713 {
1714   unsigned int nbits, min, def=2048, max=4096;
1715
1716   if(opt.expert)
1717     min=512;
1718   else
1719     min=1024;
1720
1721   switch(algo)
1722     {
1723     case PUBKEY_ALGO_DSA:
1724       if(opt.flags.dsa2)
1725         {
1726           def=1024;
1727           max=3072;
1728         }
1729       else
1730         {
1731           tty_printf(_("DSA keypair will have %u bits.\n"),1024);
1732           return 1024;
1733         }
1734       break;
1735
1736     case PUBKEY_ALGO_RSA:
1737       min=1024;
1738       break;
1739     }
1740
1741   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1742              gcry_pk_algo_name (algo), min, max);
1743
1744   for(;;)
1745     {
1746       char *prompt,*answer;
1747
1748 #define PROMPTSTRING _("What keysize do you want? (%u) ")
1749
1750       prompt=xmalloc(strlen(PROMPTSTRING)+20);
1751       sprintf(prompt,PROMPTSTRING,def);
1752
1753 #undef PROMPTSTRING
1754
1755       answer = cpr_get("keygen.size",prompt);
1756       cpr_kill_prompt();
1757       nbits = *answer? atoi(answer): def;
1758       xfree(prompt);
1759       xfree(answer);
1760       
1761       if(nbits<min || nbits>max)
1762         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1763                    gcry_pk_algo_name (algo), min, max);
1764       else
1765         break;
1766     }
1767
1768   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1769
1770   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1771     {
1772       nbits = ((nbits + 63) / 64) * 64;
1773       tty_printf(_("rounded up to %u bits\n"), nbits );
1774     }
1775   else if( (nbits % 32) )
1776     {
1777       nbits = ((nbits + 31) / 32) * 32;
1778       tty_printf(_("rounded up to %u bits\n"), nbits );
1779     }
1780
1781   return nbits;
1782 }
1783
1784
1785 /****************
1786  * Parse an expire string and return its value in seconds.
1787  * Returns (u32)-1 on error.
1788  * This isn't perfect since scan_isodatestr returns unix time, and
1789  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1790  * Because of this, we only permit setting expirations up to 2106, but
1791  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1792  * just cope for the next few years until we get a 64-bit time_t or
1793  * similar.
1794  */
1795 u32
1796 parse_expire_string( const char *string )
1797 {
1798   int mult;
1799   u32 seconds;
1800   u32 abs_date = 0;
1801   u32 curtime = make_timestamp ();
1802   time_t tt;
1803   
1804   if (!*string)
1805     seconds = 0;
1806   else if (!strncmp (string, "seconds=", 8))
1807     seconds = atoi (string+8);
1808   else if ((abs_date = scan_isodatestr(string))
1809            && (abs_date+86400/2) > curtime)
1810     seconds = (abs_date+86400/2) - curtime;
1811   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
1812     seconds = (u32)tt - curtime;
1813   else if ((mult = check_valid_days (string)))
1814     seconds = atoi (string) * 86400L * mult;
1815   else
1816     seconds = (u32)(-1);
1817   
1818   return seconds;
1819 }
1820
1821 /* Parsean Creation-Date string which is either "1986-04-26" or
1822    "19860426T042640".  Returns 0 on error. */
1823 static u32
1824 parse_creation_string (const char *string)
1825 {
1826   u32 seconds;
1827   
1828   if (!*string)
1829     seconds = 0;
1830   else if ( !strncmp (string, "seconds=", 8) )
1831     seconds = atoi (string+8);
1832   else if ( !(seconds = scan_isodatestr (string)))
1833     {
1834       time_t tmp = isotime2epoch (string);
1835       seconds = (tmp == (time_t)(-1))? 0 : tmp;
1836     }
1837   return seconds;
1838 }
1839
1840
1841 /* object == 0 for a key, and 1 for a sig */
1842 u32
1843 ask_expire_interval(int object,const char *def_expire)
1844 {
1845     u32 interval;
1846     char *answer;
1847
1848     switch(object)
1849       {
1850       case 0:
1851         if(def_expire)
1852           BUG();
1853         tty_printf(_("Please specify how long the key should be valid.\n"
1854                      "         0 = key does not expire\n"
1855                      "      <n>  = key expires in n days\n"
1856                      "      <n>w = key expires in n weeks\n"
1857                      "      <n>m = key expires in n months\n"
1858                      "      <n>y = key expires in n years\n"));
1859         break;
1860
1861       case 1:
1862         if(!def_expire)
1863           BUG();
1864         tty_printf(_("Please specify how long the signature should be valid.\n"
1865                      "         0 = signature does not expire\n"
1866                      "      <n>  = signature expires in n days\n"
1867                      "      <n>w = signature expires in n weeks\n"
1868                      "      <n>m = signature expires in n months\n"
1869                      "      <n>y = signature expires in n years\n"));
1870         break;
1871
1872       default:
1873         BUG();
1874       }
1875
1876     /* Note: The elgamal subkey for DSA has no expiration date because
1877      * it must be signed with the DSA key and this one has the expiration
1878      * date */
1879
1880     answer = NULL;
1881     for(;;)
1882       {
1883         u32 curtime=make_timestamp();
1884
1885         xfree(answer);
1886         if(object==0)
1887           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1888         else
1889           {
1890             char *prompt;
1891
1892 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1893             /* This will actually end up larger than necessary because
1894                of the 2 bytes for '%s' */
1895             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1896             sprintf(prompt,PROMPTSTRING,def_expire);
1897 #undef PROMPTSTRING
1898
1899             answer = cpr_get("siggen.valid",prompt);
1900             xfree(prompt);
1901
1902             if(*answer=='\0')
1903               answer=xstrdup(def_expire);
1904           }
1905         cpr_kill_prompt();
1906         trim_spaces(answer);
1907         interval = parse_expire_string( answer );
1908         if( interval == (u32)-1 )
1909           {
1910             tty_printf(_("invalid value\n"));
1911             continue;
1912           }
1913
1914         if( !interval )
1915           {
1916             tty_printf((object==0)
1917                        ? _("Key does not expire at all\n")
1918                        : _("Signature does not expire at all\n"));
1919           }
1920         else
1921           {
1922             tty_printf(object==0
1923                        ? _("Key expires at %s\n")
1924                        : _("Signature expires at %s\n"),
1925                        asctimestamp((ulong)(curtime + interval) ) );
1926 #if SIZEOF_TIME_T <= 4
1927             if ( (time_t)((ulong)(curtime+interval)) < 0 )
1928               tty_printf (_("Your system can't display dates beyond 2038.\n"
1929                             "However, it will be correctly handled up to"
1930                             " 2106.\n"));
1931             else
1932 #endif /*SIZEOF_TIME_T*/
1933               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
1934                 {
1935                   tty_printf (_("invalid value\n"));
1936                   continue;
1937                 }
1938           }
1939
1940         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1941                                                    _("Is this correct? (y/N) ")) )
1942           break;
1943       }
1944
1945     xfree(answer);
1946     return interval;
1947 }
1948
1949 u32
1950 ask_expiredate()
1951 {
1952     u32 x = ask_expire_interval(0,NULL);
1953     return x? make_timestamp() + x : 0;
1954 }
1955
1956
1957 static char *
1958 ask_user_id( int mode )
1959 {
1960     char *answer;
1961     char *aname, *acomment, *amail, *uid;
1962
1963     if ( !mode )
1964       {
1965         /* TRANSLATORS: This is the new string telling the user what
1966            gpg is now going to do (i.e. ask for the parts of the user
1967            ID).  Note that if you do not tyranslated this string, a
1968            different string will be used used, which might still have
1969            a correct transaltion.  */
1970         const char *s1 =
1971           N_("\n"
1972              "GnuPG needs to construct a user ID to identify your key.\n"
1973              "\n");
1974         const char *s2 = _(s1);
1975
1976         if (!strcmp (s1, s2))
1977           {
1978             /* There is no translation for the string thus we to use
1979                the old info text.  gettext has no way to tell whether
1980                a translation is actually available, thus we need to
1981                to compare again. */
1982             /* TRANSLATORS: This string is in general not anymore used
1983                but you should keep your existing translation.  In case
1984                the new string is not translated this old string will
1985                be used. */
1986             const char *s3 = N_("\n"
1987 "You need a user ID to identify your key; "
1988                                         "the software constructs the user ID\n"
1989 "from the Real Name, Comment and Email Address in this form:\n"
1990 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
1991             const char *s4 = _(s3);
1992             if (strcmp (s3, s4))
1993               s2 = s3; /* A translation exists - use it. */
1994           }
1995         tty_printf ("%s", s2) ;
1996       }
1997     uid = aname = acomment = amail = NULL;
1998     for(;;) {
1999         char *p;
2000         int fail=0;
2001
2002         if( !aname ) {
2003             for(;;) {
2004                 xfree(aname);
2005                 aname = cpr_get("keygen.name",_("Real name: "));
2006                 trim_spaces(aname);
2007                 cpr_kill_prompt();
2008
2009                 if( opt.allow_freeform_uid )
2010                     break;
2011
2012                 if( strpbrk( aname, "<>" ) )
2013                     tty_printf(_("Invalid character in name\n"));
2014                 else if( digitp(aname) )
2015                     tty_printf(_("Name may not start with a digit\n"));
2016                 else if( strlen(aname) < 5 )
2017                     tty_printf(_("Name must be at least 5 characters long\n"));
2018                 else
2019                     break;
2020             }
2021         }
2022         if( !amail ) {
2023             for(;;) {
2024                 xfree(amail);
2025                 amail = cpr_get("keygen.email",_("Email address: "));
2026                 trim_spaces(amail);
2027                 cpr_kill_prompt();
2028                 if( !*amail || opt.allow_freeform_uid )
2029                     break;   /* no email address is okay */
2030                 else if ( !is_valid_mailbox (amail) )
2031                     tty_printf(_("Not a valid email address\n"));
2032                 else
2033                     break;
2034             }
2035         }
2036         if( !acomment ) {
2037             for(;;) {
2038                 xfree(acomment);
2039                 acomment = cpr_get("keygen.comment",_("Comment: "));
2040                 trim_spaces(acomment);
2041                 cpr_kill_prompt();
2042                 if( !*acomment )
2043                     break;   /* no comment is okay */
2044                 else if( strpbrk( acomment, "()" ) )
2045                     tty_printf(_("Invalid character in comment\n"));
2046                 else
2047                     break;
2048             }
2049         }
2050
2051
2052         xfree(uid);
2053         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2054         p = stpcpy(p, aname );
2055         if( *acomment )
2056             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2057         if( *amail )
2058             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2059
2060         /* Append a warning if the RNG is switched into fake mode.  */
2061         if ( random_is_faked ()  )
2062           strcpy(p, " (insecure!)" );
2063
2064         /* print a note in case that UTF8 mapping has to be done */
2065         for(p=uid; *p; p++ ) {
2066             if( *p & 0x80 ) {
2067                 tty_printf(_("You are using the `%s' character set.\n"),
2068                            get_native_charset() );
2069                 break;
2070             }
2071         }
2072
2073         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2074         /* fixme: add a warning if this user-id already exists */
2075         if( !*amail && !opt.allow_freeform_uid
2076             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2077             fail = 1;
2078             tty_printf(_("Please don't put the email address "
2079                           "into the real name or the comment\n") );
2080         }
2081
2082         for(;;) {
2083             /* TRANSLATORS: These are the allowed answers in
2084                lower and uppercase.  Below you will find the matching
2085                string which should be translated accordingly and the
2086                letter changed to match the one in the answer string.
2087                
2088                  n = Change name
2089                  c = Change comment
2090                  e = Change email
2091                  o = Okay (ready, continue)
2092                  q = Quit
2093              */
2094             const char *ansstr = _("NnCcEeOoQq");
2095
2096             if( strlen(ansstr) != 10 )
2097                 BUG();
2098             if( cpr_enabled() ) {
2099                 answer = xstrdup(ansstr+6);
2100                 answer[1] = 0;
2101             }
2102             else {
2103                 answer = cpr_get("keygen.userid.cmd", fail?
2104                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2105                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2106                 cpr_kill_prompt();
2107             }
2108             if( strlen(answer) > 1 )
2109                 ;
2110             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2111                 xfree(aname); aname = NULL;
2112                 break;
2113             }
2114             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2115                 xfree(acomment); acomment = NULL;
2116                 break;
2117             }
2118             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2119                 xfree(amail); amail = NULL;
2120                 break;
2121             }
2122             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2123                 if( fail ) {
2124                     tty_printf(_("Please correct the error first\n"));
2125                 }
2126                 else {
2127                     xfree(aname); aname = NULL;
2128                     xfree(acomment); acomment = NULL;
2129                     xfree(amail); amail = NULL;
2130                     break;
2131                 }
2132             }
2133             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2134                 xfree(aname); aname = NULL;
2135                 xfree(acomment); acomment = NULL;
2136                 xfree(amail); amail = NULL;
2137                 xfree(uid); uid = NULL;
2138                 break;
2139             }
2140             xfree(answer);
2141         }
2142         xfree(answer);
2143         if( !amail && !acomment && !amail )
2144             break;
2145         xfree(uid); uid = NULL;
2146     }
2147     if( uid ) {
2148         char *p = native_to_utf8( uid );
2149         xfree( uid );
2150         uid = p;
2151     }
2152     return uid;
2153 }
2154
2155
2156 static DEK *
2157 do_ask_passphrase ( STRING2KEY **ret_s2k, int *r_canceled )
2158 {
2159     DEK *dek = NULL;
2160     STRING2KEY *s2k;
2161     const char *errtext = NULL;
2162
2163     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2164
2165     s2k = xmalloc_secure( sizeof *s2k );
2166     for(;;) {
2167         s2k->mode = opt.s2k_mode;
2168         s2k->hash_algo = S2K_DIGEST_ALGO;
2169         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
2170                                  errtext, r_canceled);
2171         if (!dek && *r_canceled) {
2172             xfree(dek); dek = NULL;
2173             xfree(s2k); s2k = NULL;
2174             break;
2175         }
2176         else if( !dek ) {
2177             errtext = N_("passphrase not correctly repeated; try again");
2178             tty_printf(_("%s.\n"), _(errtext));
2179         }
2180         else if( !dek->keylen ) {
2181             xfree(dek); dek = NULL;
2182             xfree(s2k); s2k = NULL;
2183             tty_printf(_(
2184             "You don't want a passphrase - this is probably a *bad* idea!\n"
2185             "I will do it anyway.  You can change your passphrase at any time,\n"
2186             "using this program with the option \"--edit-key\".\n\n"));
2187             break;
2188         }
2189         else
2190             break; /* okay */
2191     }
2192     *ret_s2k = s2k;
2193     return dek;
2194 }
2195
2196
2197 /* Basic key generation.  Here we divert to the actual generation
2198    routines based on the requested algorithm.  */
2199 static int
2200 do_create (int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
2201            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, 
2202            u32 timestamp, u32 expiredate, int is_subkey )
2203 {
2204   int rc=0;
2205
2206   if( !opt.batch )
2207     tty_printf(_(
2208 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2209 "some other action (type on the keyboard, move the mouse, utilize the\n"
2210 "disks) during the prime generation; this gives the random number\n"
2211 "generator a better chance to gain enough entropy.\n") );
2212
2213   if( algo == PUBKEY_ALGO_ELGAMAL_E )
2214     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2215                  timestamp, expiredate, is_subkey);
2216   else if( algo == PUBKEY_ALGO_DSA )
2217     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk,
2218                  timestamp, expiredate, is_subkey);
2219   else if( algo == PUBKEY_ALGO_RSA )
2220     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2221                  timestamp, expiredate, is_subkey);
2222   else
2223     BUG();
2224
2225   return rc;
2226 }
2227
2228
2229 /****************
2230  * Generate a new user id packet, or return NULL if canceled
2231  */
2232 PKT_user_id *
2233 generate_user_id()
2234 {
2235     PKT_user_id *uid;
2236     char *p;
2237     size_t n;
2238
2239     p = ask_user_id( 1 );
2240     if( !p )
2241         return NULL;
2242     n = strlen(p);
2243     uid = xmalloc_clear( sizeof *uid + n );
2244     uid->len = n;
2245     strcpy(uid->name, p);
2246     uid->ref = 1;
2247     return uid;
2248 }
2249
2250
2251 static void
2252 release_parameter_list( struct para_data_s *r )
2253 {
2254     struct para_data_s *r2;
2255
2256     for( ; r ; r = r2 ) {
2257         r2 = r->next;
2258         if( r->key == pPASSPHRASE_DEK )
2259             xfree( r->u.dek );
2260         else if( r->key == pPASSPHRASE_S2K )
2261             xfree( r->u.s2k );
2262
2263         xfree(r);
2264     }
2265 }
2266
2267 static struct para_data_s *
2268 get_parameter( struct para_data_s *para, enum para_name key )
2269 {
2270     struct para_data_s *r;
2271
2272     for( r = para; r && r->key != key; r = r->next )
2273         ;
2274     return r;
2275 }
2276
2277 static const char *
2278 get_parameter_value( struct para_data_s *para, enum para_name key )
2279 {
2280     struct para_data_s *r = get_parameter( para, key );
2281     return (r && *r->u.value)? r->u.value : NULL;
2282 }
2283
2284 static int
2285 get_parameter_algo( struct para_data_s *para, enum para_name key )
2286 {
2287     int i;
2288     struct para_data_s *r = get_parameter( para, key );
2289     if( !r )
2290         return -1;
2291     if( digitp( r->u.value ) )
2292         i = atoi( r->u.value );
2293     else if ( !strcmp ( r->u.value, "ELG-E")
2294               || !strcmp ( r->u.value, "ELG") )
2295         i = GCRY_PK_ELG_E;
2296     else
2297         i = gcry_pk_map_name (r->u.value);
2298     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2299       i = 0; /* we don't want to allow generation of these algorithms */
2300     return i;
2301 }
2302
2303 /* 
2304  * Parse the usage parameter and set the keyflags.  Returns -1 on
2305  * error, 0 for no usage given or 1 for usage available.
2306  */
2307 static int
2308 parse_parameter_usage (const char *fname,
2309                        struct para_data_s *para, enum para_name key)
2310 {
2311     struct para_data_s *r = get_parameter( para, key );
2312     char *p, *pn;
2313     unsigned int use;
2314
2315     if( !r )
2316         return 0; /* none (this is an optional parameter)*/
2317     
2318     use = 0;
2319     pn = r->u.value;
2320     while ( (p = strsep (&pn, " \t,")) ) {
2321         if ( !*p)
2322             ;
2323         else if ( !ascii_strcasecmp (p, "sign") )
2324             use |= PUBKEY_USAGE_SIG;
2325         else if ( !ascii_strcasecmp (p, "encrypt") )
2326             use |= PUBKEY_USAGE_ENC;
2327         else if ( !ascii_strcasecmp (p, "auth") )
2328             use |= PUBKEY_USAGE_AUTH;
2329         else {
2330             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2331             return -1; /* error */
2332         }
2333     }
2334     r->u.usage = use;
2335     return 1;
2336 }
2337
2338 static int
2339 parse_revocation_key (const char *fname,
2340                       struct para_data_s *para, enum para_name key)
2341 {
2342   struct para_data_s *r = get_parameter( para, key );
2343   struct revocation_key revkey;
2344   char *pn;
2345   int i;
2346
2347   if( !r )
2348     return 0; /* none (this is an optional parameter) */
2349
2350   pn = r->u.value;
2351
2352   revkey.class=0x80;
2353   revkey.algid=atoi(pn);
2354   if(!revkey.algid)
2355     goto fail;
2356
2357   /* Skip to the fpr */
2358   while(*pn && *pn!=':')
2359     pn++;
2360
2361   if(*pn!=':')
2362     goto fail;
2363
2364   pn++;
2365
2366   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2367     {
2368       int c=hextobyte(pn);
2369       if(c==-1)
2370         goto fail;
2371
2372       revkey.fpr[i]=c;
2373     }
2374
2375   /* skip to the tag */
2376   while(*pn && *pn!='s' && *pn!='S')
2377     pn++;
2378
2379   if(ascii_strcasecmp(pn,"sensitive")==0)
2380     revkey.class|=0x40;
2381
2382   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2383
2384   return 0;
2385
2386   fail:
2387   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2388   return -1; /* error */
2389 }
2390
2391
2392 static u32
2393 get_parameter_u32( struct para_data_s *para, enum para_name key )
2394 {
2395   struct para_data_s *r = get_parameter( para, key );
2396
2397   if( !r )
2398     return 0;
2399   if( r->key == pKEYCREATIONDATE )
2400     return r->u.creation;
2401   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2402     return r->u.expire;
2403   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2404     return r->u.usage;
2405   
2406   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2407 }
2408
2409 static unsigned int
2410 get_parameter_uint( struct para_data_s *para, enum para_name key )
2411 {
2412     return get_parameter_u32( para, key );
2413 }
2414
2415 static DEK *
2416 get_parameter_dek( struct para_data_s *para, enum para_name key )
2417 {
2418     struct para_data_s *r = get_parameter( para, key );
2419     return r? r->u.dek : NULL;
2420 }
2421
2422 static STRING2KEY *
2423 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2424 {
2425     struct para_data_s *r = get_parameter( para, key );
2426     return r? r->u.s2k : NULL;
2427 }
2428
2429 static struct revocation_key *
2430 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2431 {
2432     struct para_data_s *r = get_parameter( para, key );
2433     return r? &r->u.revkey : NULL;
2434 }
2435
2436 static int
2437 proc_parameter_file( struct para_data_s *para, const char *fname,
2438                      struct output_control_s *outctrl, int card )
2439 {
2440   struct para_data_s *r;
2441   const char *s1, *s2, *s3;
2442   size_t n;
2443   char *p;
2444   int have_user_id=0,err,algo;
2445
2446   /* Check that we have all required parameters. */
2447   r = get_parameter( para, pKEYTYPE );
2448   if(r)
2449     {
2450       algo=get_parameter_algo(para,pKEYTYPE);
2451       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2452         {
2453           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2454           return -1;
2455         }
2456     }
2457   else
2458     {
2459       log_error ("%s: no Key-Type specified\n",fname);
2460       return -1;
2461     }
2462
2463   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2464   if (!err)
2465     {
2466       /* Default to algo capabilities if key-usage is not provided */
2467       r = xmalloc_clear(sizeof(*r));
2468       r->key = pKEYUSAGE;
2469       r->u.usage = openpgp_pk_algo_usage(algo);
2470       r->next = para;
2471       para = r;
2472     }
2473   else if (err == -1)
2474     return -1;
2475   else
2476     {
2477       r = get_parameter (para, pKEYUSAGE);
2478       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2479         {
2480           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2481                      fname, r->lnr, algo);
2482           return -1;
2483         }
2484     }
2485
2486   r = get_parameter( para, pSUBKEYTYPE );
2487   if(r)
2488     {
2489       algo = get_parameter_algo (para, pSUBKEYTYPE);
2490       if (openpgp_pk_test_algo (algo))
2491         {
2492           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2493           return -1;
2494         }
2495
2496       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2497       if (!err)
2498         {
2499           /* Default to algo capabilities if subkey-usage is not
2500              provided */
2501           r = xmalloc_clear (sizeof(*r));
2502           r->key = pSUBKEYUSAGE;
2503           r->u.usage = openpgp_pk_algo_usage (algo);
2504           r->next = para;
2505           para = r;
2506         }
2507       else if (err == -1)
2508         return -1;
2509       else
2510         {
2511           r = get_parameter (para, pSUBKEYUSAGE);
2512           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2513             {
2514               log_error ("%s:%d: specified Subkey-Usage not allowed"
2515                          " for algo %d\n", fname, r->lnr, algo);
2516               return -1;
2517             }
2518         }
2519     }
2520
2521
2522   if( get_parameter_value( para, pUSERID ) )
2523     have_user_id=1;
2524   else
2525     {
2526       /* create the formatted user ID */
2527       s1 = get_parameter_value( para, pNAMEREAL );
2528       s2 = get_parameter_value( para, pNAMECOMMENT );
2529       s3 = get_parameter_value( para, pNAMEEMAIL );
2530       if( s1 || s2 || s3 )
2531         {
2532           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2533           r = xmalloc_clear( sizeof *r + n + 20 );
2534           r->key = pUSERID;
2535           p = r->u.value;
2536           if( s1 )
2537             p = stpcpy(p, s1 );
2538           if( s2 )
2539             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2540           if( s3 )
2541             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2542           r->next = para;
2543           para = r;
2544           have_user_id=1;
2545         }
2546     }
2547
2548   if(!have_user_id)
2549     {
2550       log_error("%s: no User-ID specified\n",fname);
2551       return -1;
2552     }
2553
2554   /* Set preferences, if any. */
2555   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2556
2557   /* Set keyserver, if any. */
2558   s1=get_parameter_value( para, pKEYSERVER );
2559   if(s1)
2560     {
2561       struct keyserver_spec *spec;
2562
2563       spec=parse_keyserver_uri(s1,1,NULL,0);
2564       if(spec)
2565         {
2566           free_keyserver_spec(spec);
2567           opt.def_keyserver_url=s1;
2568         }
2569       else
2570         {
2571           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2572           return -1;
2573         }
2574     }
2575
2576   /* Set revoker, if any. */
2577   if (parse_revocation_key (fname, para, pREVOKER))
2578     return -1;
2579
2580   /* Make DEK and S2K from the Passphrase. */
2581   if (outctrl->ask_passphrase)
2582     {
2583       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
2584          feature is required so that GUIs are able to do a key
2585          creation but have gpg-agent ask for the passphrase.  */
2586       int canceled = 0;
2587       STRING2KEY *s2k;
2588       DEK *dek;
2589
2590       dek = do_ask_passphrase ( &s2k, &canceled );
2591       if (dek)
2592         {
2593           r = xmalloc_clear( sizeof *r );
2594           r->key = pPASSPHRASE_DEK;
2595           r->u.dek = dek;
2596           r->next = para;
2597           para = r;
2598           r = xmalloc_clear( sizeof *r );
2599           r->key = pPASSPHRASE_S2K;
2600           r->u.s2k = s2k;
2601           r->next = para;
2602           para = r;
2603         }
2604
2605       if (canceled) 
2606         {
2607           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
2608           return -1;
2609         }
2610     }
2611   else
2612     {
2613       r = get_parameter( para, pPASSPHRASE );
2614       if ( r && *r->u.value )
2615         {
2616           /* We have a plain text passphrase - create a DEK from it.
2617            * It is a little bit ridiculous to keep it in secure memory
2618            * but because we do this always, why not here.  */
2619           STRING2KEY *s2k;
2620           DEK *dek;
2621           
2622           s2k = xmalloc_secure ( sizeof *s2k );
2623           s2k->mode = opt.s2k_mode;
2624           s2k->hash_algo = S2K_DIGEST_ALGO;
2625           set_next_passphrase ( r->u.value );
2626           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2627                                    NULL, NULL);
2628           set_next_passphrase (NULL );
2629           assert (dek);
2630           memset (r->u.value, 0, strlen(r->u.value));
2631           
2632           r = xmalloc_clear (sizeof *r);
2633           r->key = pPASSPHRASE_S2K;
2634           r->u.s2k = s2k;
2635           r->next = para;
2636           para = r;
2637           r = xmalloc_clear (sizeof *r);
2638           r->key = pPASSPHRASE_DEK;
2639           r->u.dek = dek;
2640           r->next = para;
2641           para = r;
2642         }
2643     }
2644
2645   /* Make KEYCREATIONDATE from Creation-Date.  */
2646   r = get_parameter (para, pCREATIONDATE);
2647   if (r && *r->u.value)
2648     {
2649       u32 seconds;
2650
2651       seconds = parse_creation_string (r->u.value);
2652       if (!seconds)
2653         {
2654           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
2655           return -1;
2656         }
2657       r->u.creation = seconds;
2658       r->key = pKEYCREATIONDATE;  /* Change that entry. */
2659     }
2660
2661   /* Make KEYEXPIRE from Expire-Date.  */
2662   r = get_parameter( para, pEXPIREDATE );
2663   if( r && *r->u.value )
2664     {
2665       u32 seconds;
2666
2667       seconds = parse_expire_string( r->u.value );
2668       if( seconds == (u32)-1 )
2669         {
2670           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2671           return -1;
2672         }
2673       r->u.expire = seconds;
2674       r->key = pKEYEXPIRE;  /* change hat entry */
2675       /* also set it for the subkey */
2676       r = xmalloc_clear( sizeof *r + 20 );
2677       r->key = pSUBKEYEXPIRE;
2678       r->u.expire = seconds;
2679       r->next = para;
2680       para = r;
2681     }
2682
2683   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2684     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2685     return -1;
2686   }
2687
2688   do_generate_keypair( para, outctrl, card );
2689   return 0;
2690 }
2691
2692
2693 /****************
2694  * Kludge to allow non interactive key generation controlled
2695  * by a parameter file.
2696  * Note, that string parameters are expected to be in UTF-8
2697  */
2698 static void
2699 read_parameter_file( const char *fname )
2700 {
2701     static struct { const char *name;
2702                     enum para_name key;
2703     } keywords[] = {
2704         { "Key-Type",       pKEYTYPE},
2705         { "Key-Length",     pKEYLENGTH },
2706         { "Key-Usage",      pKEYUSAGE },
2707         { "Subkey-Type",    pSUBKEYTYPE },
2708         { "Subkey-Length",  pSUBKEYLENGTH },
2709         { "Subkey-Usage",   pSUBKEYUSAGE },
2710         { "Name-Real",      pNAMEREAL },
2711         { "Name-Email",     pNAMEEMAIL },
2712         { "Name-Comment",   pNAMECOMMENT },
2713         { "Expire-Date",    pEXPIREDATE },
2714         { "Creation-Date",  pCREATIONDATE },
2715         { "Passphrase",     pPASSPHRASE },
2716         { "Preferences",    pPREFERENCES },
2717         { "Revoker",        pREVOKER },
2718         { "Handle",         pHANDLE },
2719         { "Keyserver",      pKEYSERVER },
2720         { NULL, 0 }
2721     };
2722     IOBUF fp;
2723     byte *line;
2724     unsigned int maxlen, nline;
2725     char *p;
2726     int lnr;
2727     const char *err = NULL;
2728     struct para_data_s *para, *r;
2729     int i;
2730     struct output_control_s outctrl;
2731
2732     memset( &outctrl, 0, sizeof( outctrl ) );
2733     outctrl.pub.afx = new_armor_context ();
2734     outctrl.sec.afx = new_armor_context ();
2735
2736     if( !fname || !*fname)
2737       fname = "-";
2738
2739     fp = iobuf_open (fname);
2740     if (fp && is_secured_file (iobuf_get_fd (fp)))
2741       {
2742         iobuf_close (fp);
2743         fp = NULL;
2744         errno = EPERM;
2745       }
2746     if (!fp) {
2747       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2748       return;
2749     }
2750     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2751
2752     lnr = 0;
2753     err = NULL;
2754     para = NULL;
2755     maxlen = 1024;
2756     line = NULL;
2757     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2758         char *keyword, *value;
2759
2760         lnr++;
2761         if( !maxlen ) {
2762             err = "line too long";
2763             break;
2764         }
2765         for( p = line; isspace(*(byte*)p); p++ )
2766             ;
2767         if( !*p || *p == '#' )
2768             continue;
2769         keyword = p;
2770         if( *keyword == '%' ) {
2771             for( ; !isspace(*(byte*)p); p++ )
2772                 ;
2773             if( *p )
2774                 *p++ = 0;
2775             for( ; isspace(*(byte*)p); p++ )
2776                 ;
2777             value = p;
2778             trim_trailing_ws( value, strlen(value) );
2779             if( !ascii_strcasecmp( keyword, "%echo" ) )
2780                 log_info("%s\n", value );
2781             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2782                 outctrl.dryrun = 1;
2783             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
2784                 outctrl.ask_passphrase = 1;
2785             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
2786                 outctrl.ask_passphrase = 0;
2787             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2788                 outctrl.lnr = lnr;
2789                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2790                   print_status_key_not_created 
2791                     (get_parameter_value (para, pHANDLE));
2792                 release_parameter_list( para );
2793                 para = NULL;
2794             }
2795             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2796                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2797                     ; /* still the same file - ignore it */
2798                 else {
2799                     xfree( outctrl.pub.newfname );
2800                     outctrl.pub.newfname = xstrdup( value );
2801                     outctrl.use_files = 1;
2802                 }
2803             }
2804             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2805                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2806                     ; /* still the same file - ignore it */
2807                 else {
2808                    xfree( outctrl.sec.newfname );
2809                    outctrl.sec.newfname = xstrdup( value );
2810                    outctrl.use_files = 1;
2811                 }
2812             }
2813             else
2814                 log_info("skipping control `%s' (%s)\n", keyword, value );
2815
2816
2817             continue;
2818         }
2819
2820
2821         if( !(p = strchr( p, ':' )) || p == keyword ) {
2822             err = "missing colon";
2823             break;
2824         }
2825         if( *p )
2826             *p++ = 0;
2827         for( ; isspace(*(byte*)p); p++ )
2828             ;
2829         if( !*p ) {
2830             err = "missing argument";
2831             break;
2832         }
2833         value = p;
2834         trim_trailing_ws( value, strlen(value) );
2835
2836         for(i=0; keywords[i].name; i++ ) {
2837             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2838                 break;
2839         }
2840         if( !keywords[i].name ) {
2841             err = "unknown keyword";
2842             break;
2843         }
2844         if( keywords[i].key != pKEYTYPE && !para ) {
2845             err = "parameter block does not start with \"Key-Type\"";
2846             break;
2847         }
2848
2849         if( keywords[i].key == pKEYTYPE && para ) {
2850             outctrl.lnr = lnr;
2851             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2852               print_status_key_not_created
2853                 (get_parameter_value (para, pHANDLE));
2854             release_parameter_list( para );
2855             para = NULL;
2856         }
2857         else {
2858             for( r = para; r; r = r->next ) {
2859                 if( r->key == keywords[i].key )
2860                     break;
2861             }
2862             if( r ) {
2863                 err = "duplicate keyword";
2864                 break;
2865             }
2866         }
2867         r = xmalloc_clear( sizeof *r + strlen( value ) );
2868         r->lnr = lnr;
2869         r->key = keywords[i].key;
2870         strcpy( r->u.value, value );
2871         r->next = para;
2872         para = r;
2873     }
2874     if( err )
2875         log_error("%s:%d: %s\n", fname, lnr, err );
2876     else if( iobuf_error (fp) ) {
2877         log_error("%s:%d: read error\n", fname, lnr);
2878     }
2879     else if( para ) {
2880         outctrl.lnr = lnr;
2881         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2882           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2883     }
2884
2885     if( outctrl.use_files ) { /* close open streams */
2886         iobuf_close( outctrl.pub.stream );
2887         iobuf_close( outctrl.sec.stream );
2888
2889         /* Must invalidate that ugly cache to actually close it.  */
2890         if (outctrl.pub.fname)
2891           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2892         if (outctrl.sec.fname)
2893           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2894
2895         xfree( outctrl.pub.fname );
2896         xfree( outctrl.pub.newfname );
2897         xfree( outctrl.sec.fname );
2898         xfree( outctrl.sec.newfname );
2899     }
2900
2901     release_parameter_list( para );
2902     iobuf_close (fp);
2903     release_armor_context (outctrl.pub.afx);
2904     release_armor_context (outctrl.sec.afx);
2905 }
2906
2907
2908 /*
2909  * Generate a keypair (fname is only used in batch mode) If
2910  * CARD_SERIALNO is not NULL the function will create the keys on an
2911  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2912  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2913  * generate in software, imported to the card and a backup file
2914  * written to directory given by this argument .
2915  */
2916 void
2917 generate_keypair (const char *fname, const char *card_serialno, 
2918                   const char *backup_encryption_dir)
2919 {
2920   unsigned int nbits;
2921   char *uid = NULL;
2922   DEK *dek;
2923   STRING2KEY *s2k;
2924   int algo;
2925   unsigned int use;
2926   int both = 0;
2927   u32 expire;
2928   struct para_data_s *para = NULL;
2929   struct para_data_s *r;
2930   struct output_control_s outctrl;
2931   int canceled;
2932   
2933   memset( &outctrl, 0, sizeof( outctrl ) );
2934   
2935   if (opt.batch && card_serialno)
2936     {
2937       /* We don't yet support unattended key generation. */
2938       log_error (_("can't do this in batch mode\n"));
2939       return;
2940     }
2941   
2942   if (opt.batch)
2943     {
2944       read_parameter_file( fname );
2945       return;
2946     }
2947
2948   if (card_serialno)
2949     {
2950 #ifdef ENABLE_CARD_SUPPORT
2951       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2952       r->key = pSERIALNO;
2953       strcpy( r->u.value, card_serialno);
2954       r->next = para;
2955       para = r;
2956        
2957       algo = PUBKEY_ALGO_RSA;
2958        
2959       r = xcalloc (1, sizeof *r + 20 );
2960       r->key = pKEYTYPE;
2961       sprintf( r->u.value, "%d", algo );
2962       r->next = para;
2963       para = r;
2964       r = xcalloc (1, sizeof *r + 20 );
2965       r->key = pKEYUSAGE;
2966       strcpy (r->u.value, "sign");
2967       r->next = para;
2968       para = r;
2969        
2970       r = xcalloc (1, sizeof *r + 20 );
2971       r->key = pSUBKEYTYPE;
2972       sprintf( r->u.value, "%d", algo );
2973       r->next = para;
2974       para = r;
2975       r = xcalloc (1, sizeof *r + 20 );
2976       r->key = pSUBKEYUSAGE;
2977       strcpy (r->u.value, "encrypt");
2978       r->next = para;
2979       para = r;
2980        
2981       r = xcalloc (1, sizeof *r + 20 );
2982       r->key = pAUTHKEYTYPE;
2983       sprintf( r->u.value, "%d", algo );
2984       r->next = para;
2985       para = r;
2986
2987       if (backup_encryption_dir)
2988         {
2989           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2990           r->key = pBACKUPENCDIR;
2991           strcpy (r->u.value, backup_encryption_dir);
2992           r->next = para;
2993           para = r;
2994         }
2995 #endif /*ENABLE_CARD_SUPPORT*/
2996     }
2997   else
2998     {
2999       algo = ask_algo( 0, &use );
3000       if( !algo )
3001         { /* default: DSA with ElG subkey of the specified size */
3002           both = 1;
3003           r = xmalloc_clear( sizeof *r + 20 );
3004           r->key = pKEYTYPE;
3005           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
3006           r->next = para;
3007           para = r;
3008           nbits = ask_keysize( PUBKEY_ALGO_DSA );
3009           r = xmalloc_clear( sizeof *r + 20 );
3010           r->key = pKEYLENGTH;
3011           sprintf( r->u.value, "%u", nbits);
3012           r->next = para;
3013           para = r;
3014           r = xmalloc_clear( sizeof *r + 20 );
3015           r->key = pKEYUSAGE;
3016           strcpy( r->u.value, "sign" );
3017           r->next = para;
3018           para = r;
3019            
3020           algo = PUBKEY_ALGO_ELGAMAL_E;
3021           r = xmalloc_clear( sizeof *r + 20 );
3022           r->key = pSUBKEYTYPE;
3023           sprintf( r->u.value, "%d", algo );
3024           r->next = para;
3025           para = r;
3026           r = xmalloc_clear( sizeof *r + 20 );
3027           r->key = pSUBKEYUSAGE;
3028           strcpy( r->u.value, "encrypt" );
3029           r->next = para;
3030           para = r;
3031         }
3032       else 
3033         {
3034           r = xmalloc_clear( sizeof *r + 20 );
3035           r->key = pKEYTYPE;
3036           sprintf( r->u.value, "%d", algo );
3037           r->next = para;
3038           para = r;
3039            
3040           if (use)
3041             {
3042               r = xmalloc_clear( sizeof *r + 25 );
3043               r->key = pKEYUSAGE;
3044               sprintf( r->u.value, "%s%s%s",
3045                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3046                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3047                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3048               r->next = para;
3049               para = r;
3050             }
3051            
3052         }
3053
3054       nbits = ask_keysize( algo );
3055       r = xmalloc_clear( sizeof *r + 20 );
3056       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3057       sprintf( r->u.value, "%u", nbits);
3058       r->next = para;
3059       para = r;
3060     }
3061    
3062   expire = ask_expire_interval(0,NULL);
3063   r = xmalloc_clear( sizeof *r + 20 );
3064   r->key = pKEYEXPIRE;
3065   r->u.expire = expire;
3066   r->next = para;
3067   para = r;
3068   r = xmalloc_clear( sizeof *r + 20 );
3069   r->key = pSUBKEYEXPIRE;
3070   r->u.expire = expire;
3071   r->next = para;
3072   para = r;
3073
3074   uid = ask_user_id(0);
3075   if( !uid ) 
3076     {
3077       log_error(_("Key generation canceled.\n"));
3078       release_parameter_list( para );
3079       return;
3080     }
3081   r = xmalloc_clear( sizeof *r + strlen(uid) );
3082   r->key = pUSERID;
3083   strcpy( r->u.value, uid );
3084   r->next = para;
3085   para = r;
3086     
3087   canceled = 0;
3088   dek = card_serialno? NULL : do_ask_passphrase ( &s2k, &canceled );
3089   if( dek )
3090     {
3091       r = xmalloc_clear( sizeof *r );
3092       r->key = pPASSPHRASE_DEK;
3093       r->u.dek = dek;
3094       r->next = para;
3095       para = r;
3096       r = xmalloc_clear( sizeof *r );
3097       r->key = pPASSPHRASE_S2K;
3098       r->u.s2k = s2k;
3099       r->next = para;
3100       para = r;
3101     }
3102
3103   if (canceled) 
3104     log_error (_("Key generation canceled.\n"));
3105   else
3106     proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3107   release_parameter_list( para );
3108 }
3109
3110
3111 #ifdef ENABLE_CARD_SUPPORT
3112 /* Generate a raw key and return it as a secret key packet.  The
3113    function will ask for the passphrase and return a protected as well
3114    as an unprotected copy of a new secret key packet.  0 is returned
3115    on success and the caller must then free the returned values.  */
3116 static int
3117 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3118                   PKT_secret_key **r_sk_unprotected,
3119                   PKT_secret_key **r_sk_protected)
3120 {
3121   int rc;
3122   DEK *dek = NULL;
3123   STRING2KEY *s2k = NULL;
3124   PKT_secret_key *sk = NULL;
3125   int i;
3126   size_t nskey, npkey;
3127   gcry_sexp_t s_parms, s_key;
3128   int canceled;
3129
3130   npkey = pubkey_get_npkey (algo);
3131   nskey = pubkey_get_nskey (algo);
3132   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3133
3134   if (nbits < 512)
3135     {
3136       nbits = 512;
3137       log_info (_("keysize invalid; using %u bits\n"), nbits );
3138     }
3139
3140   if ((nbits % 32)) 
3141     {
3142       nbits = ((nbits + 31) / 32) * 32;
3143       log_info(_("keysize rounded up to %u bits\n"), nbits );
3144     }
3145
3146   dek = do_ask_passphrase (&s2k, &canceled);
3147   if (canceled)
3148     {
3149       rc = gpg_error (GPG_ERR_CANCELED);
3150       goto leave;
3151     }
3152
3153   sk = xmalloc_clear (sizeof *sk);
3154   sk->timestamp = created_at;
3155   sk->version = 4;
3156   sk->pubkey_algo = algo;
3157
3158   if ( !is_RSA (algo) )
3159     {
3160       log_error ("only RSA is supported for offline generated keys\n");
3161       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3162       goto leave;
3163     }
3164   rc = gcry_sexp_build (&s_parms, NULL,
3165                         "(genkey(rsa(nbits %d)))",
3166                         (int)nbits);
3167   if (rc)
3168     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3169   rc = gcry_pk_genkey (&s_key, s_parms);
3170   gcry_sexp_release (s_parms);
3171   if (rc)
3172     {
3173       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3174       goto leave;
3175     }
3176   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3177   gcry_sexp_release (s_key);
3178   if (rc) 
3179     {
3180       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3181       goto leave;
3182     }
3183   
3184   for (i=npkey; i < nskey; i++)
3185     sk->csum += checksum_mpi (sk->skey[i]);
3186
3187   if (r_sk_unprotected) 
3188     *r_sk_unprotected = copy_secret_key (NULL, sk);
3189
3190   rc = genhelp_protect (dek, s2k, sk);
3191   if (rc)
3192     goto leave;
3193
3194   if (r_sk_protected)
3195     {
3196       *r_sk_protected = sk;
3197       sk = NULL;
3198     }
3199
3200  leave:
3201   if (sk)
3202     free_secret_key (sk);
3203   xfree (dek);
3204   xfree (s2k);
3205   return rc;
3206 }
3207 #endif /* ENABLE_CARD_SUPPORT */
3208
3209 /* Create and delete a dummy packet to start off a list of kbnodes. */
3210 static void
3211 start_tree(KBNODE *tree)
3212 {
3213   PACKET *pkt;
3214
3215   pkt=xmalloc_clear(sizeof(*pkt));
3216   pkt->pkttype=PKT_NONE;
3217   *tree=new_kbnode(pkt);
3218   delete_kbnode(*tree);
3219 }
3220
3221
3222 static void
3223 do_generate_keypair (struct para_data_s *para,
3224                      struct output_control_s *outctrl, int card)
3225 {
3226   KBNODE pub_root = NULL;
3227   KBNODE sec_root = NULL;
3228   PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3229   const char *s;
3230   struct revocation_key *revkey;
3231   int rc;
3232   int did_sub = 0;
3233   u32 timestamp;
3234
3235   if( outctrl->dryrun )
3236     {
3237       log_info("dry-run mode - key generation skipped\n");
3238       return;
3239     }
3240   
3241   if ( outctrl->use_files ) 
3242     {
3243       if ( outctrl->pub.newfname ) 
3244         {
3245           iobuf_close(outctrl->pub.stream);
3246           outctrl->pub.stream = NULL;
3247           if (outctrl->pub.fname)
3248             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
3249           xfree( outctrl->pub.fname );
3250           outctrl->pub.fname =  outctrl->pub.newfname;
3251           outctrl->pub.newfname = NULL;
3252           
3253           if (is_secured_filename (outctrl->pub.fname) ) 
3254             {
3255               outctrl->pub.stream = NULL;
3256               errno = EPERM;
3257             }
3258           else
3259             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3260           if (!outctrl->pub.stream)
3261             {
3262               log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3263                         strerror(errno) );
3264               return;
3265             }
3266           if (opt.armor)
3267             {
3268               outctrl->pub.afx->what = 1;
3269               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3270             }
3271         }
3272       if (outctrl->sec.newfname)
3273         {
3274           mode_t oldmask;
3275           
3276           iobuf_close(outctrl->sec.stream);
3277           outctrl->sec.stream = NULL;
3278           if (outctrl->sec.fname)
3279             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3280           xfree( outctrl->sec.fname );
3281           outctrl->sec.fname =  outctrl->sec.newfname;
3282           outctrl->sec.newfname = NULL;
3283
3284           oldmask = umask (077);
3285           if (is_secured_filename (outctrl->sec.fname) )
3286             {
3287               outctrl->sec.stream = NULL;
3288               errno = EPERM;
3289             }
3290           else
3291             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3292           umask (oldmask);
3293           if (!outctrl->sec.stream)
3294             {
3295               log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3296                         strerror(errno) );
3297               return;
3298             }
3299           if (opt.armor)
3300             {
3301               outctrl->sec.afx->what = 5;
3302               push_armor_filter (outctrl->sec.afx, outctrl->sec.stream);
3303             }
3304         }
3305       assert( outctrl->pub.stream );
3306       assert( outctrl->sec.stream );
3307       if (opt.verbose)
3308         {
3309           log_info (_("writing public key to `%s'\n"), outctrl->pub.fname );
3310           if (card)
3311             log_info (_("writing secret key stub to `%s'\n"),
3312                       outctrl->sec.fname);
3313           else
3314             log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3315         }
3316     }
3317
3318
3319   /* We create the packets as a tree of kbnodes.  Because the
3320      structure we create is known in advance we simply generate a
3321      linked list.  The first packet is a dummy packet which we flag as
3322      deleted.  The very first packet must always be a KEY packet.  */
3323     
3324   start_tree (&pub_root);
3325   start_tree (&sec_root);
3326
3327   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3328   if (!timestamp)
3329     timestamp = make_timestamp ();
3330
3331   if (!card)
3332     {
3333       rc = do_create (get_parameter_algo( para, pKEYTYPE ),
3334                       get_parameter_uint( para, pKEYLENGTH ),
3335                       pub_root, sec_root,
3336                       get_parameter_dek( para, pPASSPHRASE_DEK ),
3337                       get_parameter_s2k( para, pPASSPHRASE_S2K ),
3338                       &pri_sk,
3339                       timestamp,
3340                       get_parameter_u32( para, pKEYEXPIRE ), 0 );
3341     }
3342   else
3343     {
3344       /* Note, that depending on the backend, the card key generation
3345          may update TIMESTAMP.  */
3346       rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root, NULL,
3347                          &timestamp,
3348                          get_parameter_u32 (para, pKEYEXPIRE), para);
3349       if (!rc)
3350         {
3351           pri_sk = sec_root->next->pkt->pkt.secret_key;
3352           assert (pri_sk);
3353         }
3354     }
3355
3356   if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3357     {
3358       rc = write_direct_sig (pub_root, pub_root, pri_sk, revkey, timestamp);
3359       if (!rc)
3360         rc = write_direct_sig (sec_root, pub_root, pri_sk, revkey, timestamp);
3361     }
3362
3363   if( !rc && (s=get_parameter_value(para, pUSERID)) )
3364     {
3365       write_uid (pub_root, s );
3366       write_uid (sec_root, s );
3367
3368       rc = write_selfsigs (sec_root, pub_root, pri_sk,
3369                            get_parameter_uint (para, pKEYUSAGE), timestamp);
3370     }
3371
3372   /* Write the auth key to the card before the encryption key.  This
3373      is a partial workaround for a PGP bug (as of this writing, all
3374      versions including 8.1), that causes it to try and encrypt to
3375      the most recent subkey regardless of whether that subkey is
3376      actually an encryption type.  In this case, the auth key is an
3377      RSA key so it succeeds. */
3378
3379   if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3380     {
3381       /* Note, that depending on the backend, the card key generation
3382          may update TIMESTAMP.  */
3383       rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root, NULL,
3384                          &timestamp,
3385                          get_parameter_u32 (para, pKEYEXPIRE), para);
3386         
3387       if (!rc)
3388         rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk,
3389                                PUBKEY_USAGE_AUTH, timestamp);
3390       if (!rc)
3391         rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk,
3392                                PUBKEY_USAGE_AUTH, timestamp);
3393     }
3394
3395   if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3396     {
3397       if (!card)
3398         {
3399           rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
3400                           get_parameter_uint( para, pSUBKEYLENGTH ),
3401                           pub_root, sec_root,
3402                           get_parameter_dek( para, pPASSPHRASE_DEK ),
3403                           get_parameter_s2k( para, pPASSPHRASE_S2K ),
3404                           &sub_sk,
3405                           timestamp,
3406                           get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3407         }
3408       else
3409         {
3410           if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3411             {
3412               /* A backup of the encryption key has been requested.
3413                  Generate the key in software and import it then to
3414                  the card.  Write a backup file. */
3415               rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3416                                              pub_root, sec_root,
3417                                              timestamp,
3418                                              get_parameter_u32 (para,
3419                                                                 pKEYEXPIRE),
3420                                              para, s);
3421             }
3422           else
3423             {
3424               /* Note, that depending on the backend, the card key
3425                  generation may update TIMESTAMP.  */
3426               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3427                                  NULL,
3428                                  &timestamp,
3429                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3430             }
3431         }
3432
3433       if( !rc )
3434         rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
3435                               get_parameter_uint (para, pSUBKEYUSAGE),
3436                               timestamp);
3437       if( !rc )
3438         rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
3439                               get_parameter_uint (para, pSUBKEYUSAGE),
3440                               timestamp);
3441       did_sub = 1;
3442     }
3443
3444   if (!rc && outctrl->use_files)  /* Direct write to specified files.  */
3445     {
3446       rc = write_keyblock( outctrl->pub.stream, pub_root );
3447       if (rc)
3448         log_error ("can't write public key: %s\n", g10_errstr(rc) );
3449       if (!rc) 
3450         {
3451           rc = write_keyblock( outctrl->sec.stream, sec_root );
3452           if(rc)
3453             log_error ("can't write secret key: %s\n", g10_errstr(rc) );
3454         }
3455     }
3456   else if (!rc) /* Write to the standard keyrings.  */
3457     {
3458       KEYDB_HANDLE pub_hd = keydb_new (0);
3459       KEYDB_HANDLE sec_hd = keydb_new (1);
3460
3461       rc = keydb_locate_writable (pub_hd, NULL);
3462       if (rc) 
3463         log_error (_("no writable public keyring found: %s\n"),
3464                    g10_errstr (rc));
3465
3466       if (!rc) 
3467         {  
3468           rc = keydb_locate_writable (sec_hd, NULL);
3469           if (rc) 
3470             log_error (_("no writable secret keyring found: %s\n"),
3471                        g10_errstr (rc));
3472         }
3473       
3474       if (!rc && opt.verbose)
3475         {
3476           log_info (_("writing public key to `%s'\n"),
3477                     keydb_get_resource_name (pub_hd));
3478           if (card)
3479             log_info (_("writing secret key stub to `%s'\n"),
3480                       keydb_get_resource_name (sec_hd));
3481           else
3482             log_info (_("writing secret key to `%s'\n"),
3483                       keydb_get_resource_name (sec_hd));
3484         }
3485       
3486       if (!rc) 
3487         {
3488           rc = keydb_insert_keyblock (pub_hd, pub_root);
3489           if (rc)
3490             log_error (_("error writing public keyring `%s': %s\n"),
3491                        keydb_get_resource_name (pub_hd), g10_errstr(rc));
3492         }
3493       
3494       if (!rc)
3495         {
3496           rc = keydb_insert_keyblock (sec_hd, sec_root);
3497           if (rc)
3498             log_error (_("error writing secret keyring `%s': %s\n"),
3499                        keydb_get_resource_name (pub_hd), g10_errstr(rc));
3500         }
3501
3502       keydb_release (pub_hd);
3503       keydb_release (sec_hd);
3504       
3505       if (!rc)
3506         {
3507           int no_enc_rsa;
3508           PKT_public_key *pk;
3509
3510           no_enc_rsa = (get_parameter_algo (para, pKEYTYPE) == PUBKEY_ALGO_RSA
3511                         && get_parameter_uint (para, pKEYUSAGE)
3512                         && !((get_parameter_uint (para, pKEYUSAGE)
3513                               & PUBKEY_USAGE_ENC)) );
3514
3515           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3516
3517           keyid_from_pk(pk,pk->main_keyid);
3518           register_trusted_keyid(pk->main_keyid);
3519
3520           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
3521                                   | TRUST_ULTIMATE ));
3522
3523           if (!opt.batch) 
3524             {
3525               tty_printf (_("public and secret key created and signed.\n") );
3526               tty_printf ("\n");
3527               list_keyblock(pub_root,0,1,NULL);
3528             }
3529             
3530           
3531           if (!opt.batch
3532               && (get_parameter_algo (para, pKEYTYPE) == PUBKEY_ALGO_DSA
3533                   || no_enc_rsa )
3534               && !get_parameter (para, pSUBKEYTYPE) )
3535             {
3536               tty_printf(_("Note that this key cannot be used for "
3537                            "encryption.  You may want to use\n"
3538                            "the command \"--edit-key\" to generate a "
3539                            "subkey for this purpose.\n") );
3540             }
3541         }
3542     }
3543
3544   if (rc)
3545     {
3546       if (opt.batch)
3547         log_error ("key generation failed: %s\n", g10_errstr(rc) );
3548       else
3549         tty_printf (_("Key generation failed: %s\n"), g10_errstr(rc) );
3550       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3551     }
3552   else
3553     {
3554       PKT_public_key *pk = find_kbnode (pub_root, 
3555                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3556       print_status_key_created (did_sub? 'B':'P', pk,
3557                                 get_parameter_value (para, pHANDLE));
3558     }
3559   release_kbnode( pub_root );
3560   release_kbnode( sec_root );
3561   
3562   if (pri_sk && !card)        /* The unprotected secret key unless we */
3563     free_secret_key (pri_sk); /* have a shallow copy in card mode. */
3564   if (sub_sk)
3565     free_secret_key(sub_sk);
3566 }
3567
3568
3569 /* Add a new subkey to an existing key.  Returns true if a new key has
3570    been generated and put into the keyblocks.  */
3571 int
3572 generate_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock)
3573 {
3574   int okay=0, rc=0;
3575   KBNODE node;
3576   PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3577   int algo;
3578   unsigned int use;
3579   u32 expire;
3580   unsigned nbits;
3581   char *passphrase = NULL;
3582   DEK *dek = NULL;
3583   STRING2KEY *s2k = NULL;
3584   u32 cur_time;
3585   int ask_pass = 0;
3586   int canceled;
3587
3588   /* Break out the primary secret key.  */
3589   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3590   if( !node ) 
3591     {
3592       log_error ("Oops; secret key not found anymore!\n");
3593       goto leave;
3594     }
3595   
3596   /* Make a copy of the sk to keep the protected one in the keyblock. */
3597   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3598
3599   cur_time = make_timestamp();
3600
3601   if (pri_sk->timestamp > cur_time)
3602     {
3603       ulong d = pri_sk->timestamp - cur_time;
3604       log_info ( d==1 ? _("key has been created %lu second "
3605                           "in future (time warp or clock problem)\n")
3606                  : _("key has been created %lu seconds "
3607                      "in future (time warp or clock problem)\n"), d );
3608       if (!opt.ignore_time_conflict)
3609         {
3610           rc = G10ERR_TIME_CONFLICT;
3611           goto leave;
3612         }
3613     }
3614
3615   if (pri_sk->version < 4) 
3616     {
3617       log_info (_("NOTE: creating subkeys for v3 keys "
3618                   "is not OpenPGP compliant\n"));
3619       goto leave;
3620     }
3621
3622   if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001)
3623     {
3624       tty_printf (_("Secret parts of primary key are not available.\n"));
3625       rc = G10ERR_NO_SECKEY;
3626       goto leave;
3627     }
3628
3629
3630   /* Unprotect to get the passphrase.  */
3631   switch (is_secret_key_protected (pri_sk) )
3632     {
3633     case -1:
3634       rc = G10ERR_PUBKEY_ALGO;
3635       break;
3636     case 0:
3637       tty_printf (_("This key is not protected.\n"));
3638       break;
3639     case -2:
3640       tty_printf (_("Secret parts of primary key are stored on-card.\n"));
3641       ask_pass = 1;
3642       break;
3643     default:
3644       tty_printf (_("Key is protected.\n"));
3645       rc = check_secret_key ( pri_sk, 0 );
3646       if (!rc)
3647         passphrase = get_last_passphrase();
3648       break;
3649     }
3650   if (rc)
3651     goto leave;
3652
3653   algo = ask_algo (1, &use);
3654   assert (algo);
3655   nbits = ask_keysize (algo);
3656   expire = ask_expire_interval (0, NULL);
3657   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3658                                                _("Really create? (y/N) ")))
3659     goto leave;
3660   
3661   canceled = 0;
3662   if (ask_pass)
3663     dek = do_ask_passphrase (&s2k, &canceled);
3664   else if (passphrase)
3665     {
3666       s2k = xmalloc_secure ( sizeof *s2k );
3667       s2k->mode = opt.s2k_mode;
3668       s2k->hash_algo = S2K_DIGEST_ALGO;
3669       set_next_passphrase ( passphrase );
3670       dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3671                                NULL, NULL );
3672     }
3673   
3674   if (canceled)
3675     rc = GPG_ERR_CANCELED;
3676   
3677   if (!rc)
3678     rc = do_create (algo, nbits, pub_keyblock, sec_keyblock,
3679                     dek, s2k, &sub_sk, cur_time, expire, 1 );
3680   if (!rc)
3681     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, 
3682                           use, cur_time);
3683   if (!rc)
3684     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, 
3685                            use, cur_time);
3686   if (!rc) 
3687     {
3688       okay = 1;
3689       write_status_text (STATUS_KEY_CREATED, "S");
3690     }
3691
3692  leave:
3693   if (rc)
3694     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3695   xfree (passphrase);
3696   xfree (dek);
3697   xfree (s2k);
3698   /* Release the copy of the (now unprotected) secret keys.  */
3699   if (pri_sk)
3700     free_secret_key (pri_sk);
3701   if (sub_sk)
3702     free_secret_key (sub_sk);
3703   set_next_passphrase (NULL);
3704   return okay;
3705 }
3706
3707
3708 #ifdef ENABLE_CARD_SUPPORT
3709 /* Generate a subkey on a card. */
3710 int
3711 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3712                           int keyno, const char *serialno)
3713 {
3714   int okay=0, rc=0;
3715   KBNODE node;
3716   PKT_secret_key *pri_sk = NULL, *sub_sk;
3717   int algo;
3718   unsigned int use;
3719   u32 expire;
3720   char *passphrase = NULL;
3721   u32 cur_time;
3722   struct para_data_s *para = NULL;
3723
3724   assert (keyno >= 1 && keyno <= 3);
3725
3726   para = xcalloc (1, sizeof *para + strlen (serialno) );
3727   para->key = pSERIALNO;
3728   strcpy (para->u.value, serialno);
3729
3730   /* Break out the primary secret key */
3731   node = find_kbnode (sec_keyblock, PKT_SECRET_KEY);
3732   if (!node)
3733     {
3734       log_error("Oops; secret key not found anymore!\n");
3735       goto leave;
3736     }
3737
3738   /* Make a copy of the sk to keep the protected one in the keyblock */
3739   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3740
3741   cur_time = make_timestamp();
3742   if (pri_sk->timestamp > cur_time)
3743     {
3744       ulong d = pri_sk->timestamp - cur_time;
3745       log_info (d==1 ? _("key has been created %lu second "
3746                          "in future (time warp or clock problem)\n")
3747                      : _("key has been created %lu seconds "
3748                          "in future (time warp or clock problem)\n"), d );
3749         if (!opt.ignore_time_conflict)
3750           {
3751             rc = G10ERR_TIME_CONFLICT;
3752             goto leave;
3753           }
3754     }
3755
3756   if (pri_sk->version < 4)
3757     {
3758       log_info (_("NOTE: creating subkeys for v3 keys "
3759                   "is not OpenPGP compliant\n"));
3760       goto leave;
3761     }
3762
3763   /* Unprotect to get the passphrase. */
3764   switch( is_secret_key_protected (pri_sk) )
3765     {
3766     case -1:
3767       rc = G10ERR_PUBKEY_ALGO;
3768       break;
3769     case 0:
3770       tty_printf("This key is not protected.\n");
3771       break;
3772     default:
3773       tty_printf("Key is protected.\n");
3774       rc = check_secret_key( pri_sk, 0 );
3775       if (!rc)
3776         passphrase = get_last_passphrase();
3777       break;
3778     }
3779   if (rc)
3780     goto leave;
3781
3782   algo = PUBKEY_ALGO_RSA;
3783   expire = ask_expire_interval (0,NULL);
3784   if (keyno == 1)
3785     use = PUBKEY_USAGE_SIG;
3786   else if (keyno == 2)
3787     use = PUBKEY_USAGE_ENC;
3788   else
3789     use = PUBKEY_USAGE_AUTH;
3790   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3791                                                _("Really create? (y/N) ")))
3792     goto leave;
3793
3794   if (passphrase)
3795     set_next_passphrase (passphrase);
3796
3797   /* Note, that depending on the backend, the card key generation may
3798      update CUR_TIME.  */
3799   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock,
3800                      &sub_sk, &cur_time, expire, para);
3801   if (!rc)
3802     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, 
3803                            use, cur_time);
3804   if (!rc)
3805     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, 
3806                            use, cur_time);
3807   if (!rc)
3808     {
3809       okay = 1;
3810       write_status_text (STATUS_KEY_CREATED, "S");
3811     }
3812
3813  leave:
3814   if (rc)
3815     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3816   xfree (passphrase);
3817   /* Release the copy of the (now unprotected) secret keys. */
3818   if (pri_sk)
3819     free_secret_key (pri_sk);
3820   set_next_passphrase( NULL );
3821   release_parameter_list (para);
3822   return okay;
3823 }
3824 #endif /* !ENABLE_CARD_SUPPORT */
3825
3826
3827 /*
3828  * Write a keyblock to an output stream
3829  */
3830 static int
3831 write_keyblock( IOBUF out, KBNODE node )
3832 {
3833   for( ; node ; node = node->next )
3834     {
3835       if(!is_deleted_kbnode(node))
3836         {
3837           int rc = build_packet( out, node->pkt );
3838           if( rc )
3839             {
3840               log_error("build_packet(%d) failed: %s\n",
3841                         node->pkt->pkttype, g10_errstr(rc) );
3842               return rc;
3843             }
3844         }
3845     }
3846
3847   return 0;
3848 }
3849
3850
3851 /* Note that timestamp is an in/out arg. */
3852 static int
3853 gen_card_key (int algo, int keyno, int is_primary,
3854               KBNODE pub_root, KBNODE sec_root, PKT_secret_key **ret_sk,
3855               u32 *timestamp, u32 expireval, struct para_data_s *para)
3856 {
3857 #ifdef ENABLE_CARD_SUPPORT
3858   int rc;
3859   const char *s;
3860   struct agent_card_genkey_s info;
3861   PACKET *pkt;
3862   PKT_secret_key *sk;
3863   PKT_public_key *pk;
3864
3865   assert (algo == PUBKEY_ALGO_RSA);
3866   
3867   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
3868   rc = agent_scd_genkey (&info, keyno, 1, NULL, *timestamp);
3869 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3870 /*      { */
3871 /*        tty_printf ("\n"); */
3872 /*        log_error ("WARNING: key does already exists!\n"); */
3873 /*        tty_printf ("\n"); */
3874 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3875 /*                                    _("Replace existing key? "))) */
3876 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3877 /*      } */
3878
3879   if (rc)
3880     {
3881       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3882       return rc;
3883     }
3884   if ( !info.n || !info.e )
3885     {
3886       log_error ("communication error with SCD\n");
3887       gcry_mpi_release (info.n);
3888       gcry_mpi_release (info.e);
3889       return gpg_error (GPG_ERR_GENERAL);
3890     }
3891   
3892   if (*timestamp != info.created_at)
3893     log_info ("Note that the key does not use the suggested creation date\n");
3894   *timestamp = info.created_at;
3895
3896   pk = xcalloc (1, sizeof *pk );
3897   sk = xcalloc (1, sizeof *sk );
3898   sk->timestamp = pk->timestamp = info.created_at;
3899   sk->version = pk->version = 4;
3900   if (expireval)
3901       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3902   sk->pubkey_algo = pk->pubkey_algo = algo;
3903   pk->pkey[0] = info.n;
3904   pk->pkey[1] = info.e; 
3905   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
3906   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
3907   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3908   sk->is_protected = 1;
3909   sk->protect.s2k.mode = 1002;
3910   s = get_parameter_value (para, pSERIALNO);
3911   if (s)
3912     {
3913       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3914            sk->protect.ivlen++, s += 2)
3915         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3916     }
3917
3918   if( ret_sk )
3919     *ret_sk = sk;
3920
3921   pkt = xcalloc (1,sizeof *pkt);
3922   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3923   pkt->pkt.public_key = pk;
3924   add_kbnode(pub_root, new_kbnode( pkt ));
3925
3926   pkt = xcalloc (1,sizeof *pkt);
3927   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3928   pkt->pkt.secret_key = sk;
3929   add_kbnode(sec_root, new_kbnode( pkt ));
3930
3931   return 0;
3932 #else
3933   return -1;
3934 #endif /*!ENABLE_CARD_SUPPORT*/
3935 }
3936
3937
3938
3939 static int
3940 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3941                           KBNODE pub_root, KBNODE sec_root,
3942                           u32 timestamp,
3943                           u32 expireval, struct para_data_s *para,
3944                           const char *backup_dir)
3945 {
3946 #ifdef ENABLE_CARD_SUPPORT
3947   int rc;
3948   const char *s;
3949   PACKET *pkt;
3950   PKT_secret_key *sk, *sk_unprotected = NULL, *sk_protected = NULL;
3951   PKT_public_key *pk;
3952   size_t n;
3953   int i;
3954
3955   rc = generate_raw_key (algo, 1024, timestamp,
3956                          &sk_unprotected, &sk_protected);
3957   if (rc)
3958     return rc;
3959
3960   /* First, store the key to the card. */
3961   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3962   if (rc)
3963     {
3964       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3965       free_secret_key (sk_unprotected);
3966       free_secret_key (sk_protected);
3967       return rc;
3968     }
3969
3970   /* Get rid of the secret key parameters and store the serial numer. */
3971   sk = sk_unprotected;
3972   n = pubkey_get_nskey (sk->pubkey_algo);
3973   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3974     {
3975       gcry_mpi_release (sk->skey[i]);
3976       sk->skey[i] = NULL;
3977     }
3978   i = pubkey_get_npkey (sk->pubkey_algo);
3979   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3980   sk->is_protected = 1;
3981   sk->protect.s2k.mode = 1002;
3982   s = get_parameter_value (para, pSERIALNO);
3983   assert (s);
3984   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3985        sk->protect.ivlen++, s += 2)
3986     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3987
3988   /* Now write the *protected* secret key to the file.  */
3989   {
3990     char name_buffer[50];
3991     char *fname;
3992     IOBUF fp;
3993     mode_t oldmask;
3994
3995     keyid_from_sk (sk, NULL);
3996     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
3997              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3998
3999     fname = make_filename (backup_dir, name_buffer, NULL);
4000     oldmask = umask (077);
4001     if (is_secured_filename (fname))
4002       {
4003         fp = NULL;
4004         errno = EPERM;
4005       }
4006     else
4007       fp = iobuf_create (fname);
4008     umask (oldmask);
4009     if (!fp) 
4010       {
4011         rc = gpg_error_from_syserror ();
4012         log_error (_("can't create backup file `%s': %s\n"),
4013                    fname, strerror(errno) );
4014         xfree (fname);
4015         free_secret_key (sk_unprotected);
4016         free_secret_key (sk_protected);
4017         return rc;
4018       }
4019
4020     pkt = xcalloc (1, sizeof *pkt);
4021     pkt->pkttype = PKT_SECRET_KEY;
4022     pkt->pkt.secret_key = sk_protected;
4023     sk_protected = NULL;
4024
4025     rc = build_packet (fp, pkt);
4026     if (rc)
4027       {
4028         log_error("build packet failed: %s\n", g10_errstr(rc) );
4029         iobuf_cancel (fp);
4030       }
4031     else
4032       {
4033         unsigned char array[MAX_FINGERPRINT_LEN];
4034         char *fprbuf, *p;
4035        
4036         iobuf_close (fp);
4037         iobuf_ioctl (NULL, 2, 0, (char*)fname);
4038         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
4039
4040         fingerprint_from_sk (sk, array, &n);
4041         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
4042         for (i=0; i < n ; i++, p += 2)
4043           sprintf (p, "%02X", array[i]);
4044         *p++ = ' ';
4045         *p = 0;
4046
4047         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
4048                                       fprbuf,
4049                                       fname, strlen (fname),
4050                                       0);
4051         xfree (fprbuf);
4052       }
4053     free_packet (pkt);
4054     xfree (pkt);
4055     xfree (fname);
4056     if (rc)
4057       {
4058         free_secret_key (sk_unprotected);
4059         return rc;
4060       }
4061   }
4062
4063   /* Create the public key from the secret key. */
4064   pk = xcalloc (1, sizeof *pk );
4065   pk->timestamp = sk->timestamp;
4066   pk->version = sk->version;
4067   if (expireval)
4068       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
4069   pk->pubkey_algo = sk->pubkey_algo;
4070   n = pubkey_get_npkey (sk->pubkey_algo);
4071   for (i=0; i < n; i++)
4072     pk->pkey[i] = mpi_copy (sk->skey[i]);
4073
4074   /* Build packets and add them to the node lists.  */
4075   pkt = xcalloc (1,sizeof *pkt);
4076   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
4077   pkt->pkt.public_key = pk;
4078   add_kbnode(pub_root, new_kbnode( pkt ));
4079
4080   pkt = xcalloc (1,sizeof *pkt);
4081   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
4082   pkt->pkt.secret_key = sk;
4083   add_kbnode(sec_root, new_kbnode( pkt ));
4084
4085   return 0;
4086 #else
4087   return -1;
4088 #endif /*!ENABLE_CARD_SUPPORT*/
4089 }
4090
4091
4092 #ifdef ENABLE_CARD_SUPPORT
4093 int
4094 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
4095 {
4096   int rc;
4097   unsigned char *rsa_n = NULL;
4098   unsigned char *rsa_e = NULL;
4099   unsigned char *rsa_p = NULL;
4100   unsigned char *rsa_q = NULL;
4101   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
4102   unsigned char *sexp = NULL;
4103   unsigned char *p;
4104   char numbuf[55], numbuf2[50];
4105
4106   assert (is_RSA (sk->pubkey_algo));
4107   assert (!sk->is_protected);
4108
4109   /* Copy the parameters into straight buffers. */
4110   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_n, &rsa_n_len, sk->skey[0]);
4111   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_e, &rsa_e_len, sk->skey[1]);
4112   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_p, &rsa_p_len, sk->skey[3]);
4113   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_q, &rsa_q_len, sk->skey[4]);
4114   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
4115     {
4116       rc = G10ERR_INV_ARG;
4117       goto leave;
4118     }
4119
4120    /* Put the key into an S-expression. */
4121   sexp = p = xmalloc_secure (30
4122                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
4123                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
4124
4125   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
4126   sprintf (numbuf, "%u:", (unsigned int)rsa_n_len);
4127   p = stpcpy (p, numbuf);
4128   memcpy (p, rsa_n, rsa_n_len);
4129   p += rsa_n_len;
4130
4131   sprintf (numbuf, ")(1:e%u:", (unsigned int)rsa_e_len);
4132   p = stpcpy (p, numbuf);
4133   memcpy (p, rsa_e, rsa_e_len);
4134   p += rsa_e_len;
4135
4136   sprintf (numbuf, ")(1:p%u:", (unsigned int)rsa_p_len);
4137   p = stpcpy (p, numbuf);
4138   memcpy (p, rsa_p, rsa_p_len);
4139   p += rsa_p_len;
4140
4141   sprintf (numbuf, ")(1:q%u:", (unsigned int)rsa_q_len);
4142   p = stpcpy (p, numbuf);
4143   memcpy (p, rsa_q, rsa_q_len);
4144   p += rsa_q_len;
4145
4146   p = stpcpy (p,"))(10:created-at");
4147   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
4148   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
4149   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
4150
4151   /* Fixme: Unfortunately we don't have the serialnumber available -
4152      thus we can't pass it down to the agent. */ 
4153   rc = agent_scd_writekey (keyno, NULL, sexp, p - sexp);
4154
4155  leave:
4156   xfree (sexp);
4157   xfree (rsa_n);
4158   xfree (rsa_e);
4159   xfree (rsa_p);
4160   xfree (rsa_q);
4161   return rc;
4162 }
4163 #endif /*ENABLE_CARD_SUPPORT*/