Made card key generate with backup key work for 2048 bit.
[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 /*  MODE  0 - standard
2157           1 - Ask for passphrase of the card backup key.  */
2158 static DEK *
2159 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2160 {
2161     DEK *dek = NULL;
2162     STRING2KEY *s2k;
2163     const char *errtext = NULL;
2164     const char *custdesc = NULL;
2165
2166     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2167
2168     if (mode == 1)
2169       custdesc = _("Please enter a passphrase to protect the off-card "
2170                    "backup of the new encryption key.");
2171
2172     s2k = xmalloc_secure( sizeof *s2k );
2173     for(;;) {
2174         s2k->mode = opt.s2k_mode;
2175         s2k->hash_algo = S2K_DIGEST_ALGO;
2176         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2177                                      errtext, custdesc, NULL, r_canceled);
2178         if (!dek && *r_canceled) {
2179             xfree(dek); dek = NULL;
2180             xfree(s2k); s2k = NULL;
2181             break;
2182         }
2183         else if( !dek ) {
2184             errtext = N_("passphrase not correctly repeated; try again");
2185             tty_printf(_("%s.\n"), _(errtext));
2186         }
2187         else if( !dek->keylen ) {
2188             xfree(dek); dek = NULL;
2189             xfree(s2k); s2k = NULL;
2190             tty_printf(_(
2191             "You don't want a passphrase - this is probably a *bad* idea!\n"
2192             "I will do it anyway.  You can change your passphrase at any time,\n"
2193             "using this program with the option \"--edit-key\".\n\n"));
2194             break;
2195         }
2196         else
2197             break; /* okay */
2198     }
2199     *ret_s2k = s2k;
2200     return dek;
2201 }
2202
2203
2204 /* Basic key generation.  Here we divert to the actual generation
2205    routines based on the requested algorithm.  */
2206 static int
2207 do_create (int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
2208            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, 
2209            u32 timestamp, u32 expiredate, int is_subkey )
2210 {
2211   int rc=0;
2212
2213   if( !opt.batch )
2214     tty_printf(_(
2215 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2216 "some other action (type on the keyboard, move the mouse, utilize the\n"
2217 "disks) during the prime generation; this gives the random number\n"
2218 "generator a better chance to gain enough entropy.\n") );
2219
2220   if( algo == PUBKEY_ALGO_ELGAMAL_E )
2221     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2222                  timestamp, expiredate, is_subkey);
2223   else if( algo == PUBKEY_ALGO_DSA )
2224     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk,
2225                  timestamp, expiredate, is_subkey);
2226   else if( algo == PUBKEY_ALGO_RSA )
2227     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2228                  timestamp, expiredate, is_subkey);
2229   else
2230     BUG();
2231
2232   return rc;
2233 }
2234
2235
2236 /****************
2237  * Generate a new user id packet, or return NULL if canceled
2238  */
2239 PKT_user_id *
2240 generate_user_id()
2241 {
2242     PKT_user_id *uid;
2243     char *p;
2244     size_t n;
2245
2246     p = ask_user_id( 1 );
2247     if( !p )
2248         return NULL;
2249     n = strlen(p);
2250     uid = xmalloc_clear( sizeof *uid + n );
2251     uid->len = n;
2252     strcpy(uid->name, p);
2253     uid->ref = 1;
2254     return uid;
2255 }
2256
2257
2258 static void
2259 release_parameter_list( struct para_data_s *r )
2260 {
2261     struct para_data_s *r2;
2262
2263     for( ; r ; r = r2 ) {
2264         r2 = r->next;
2265         if( r->key == pPASSPHRASE_DEK )
2266             xfree( r->u.dek );
2267         else if( r->key == pPASSPHRASE_S2K )
2268             xfree( r->u.s2k );
2269
2270         xfree(r);
2271     }
2272 }
2273
2274 static struct para_data_s *
2275 get_parameter( struct para_data_s *para, enum para_name key )
2276 {
2277     struct para_data_s *r;
2278
2279     for( r = para; r && r->key != key; r = r->next )
2280         ;
2281     return r;
2282 }
2283
2284 static const char *
2285 get_parameter_value( struct para_data_s *para, enum para_name key )
2286 {
2287     struct para_data_s *r = get_parameter( para, key );
2288     return (r && *r->u.value)? r->u.value : NULL;
2289 }
2290
2291 static int
2292 get_parameter_algo( struct para_data_s *para, enum para_name key )
2293 {
2294     int i;
2295     struct para_data_s *r = get_parameter( para, key );
2296     if( !r )
2297         return -1;
2298     if( digitp( r->u.value ) )
2299         i = atoi( r->u.value );
2300     else if ( !strcmp ( r->u.value, "ELG-E")
2301               || !strcmp ( r->u.value, "ELG") )
2302         i = GCRY_PK_ELG_E;
2303     else
2304         i = gcry_pk_map_name (r->u.value);
2305     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2306       i = 0; /* we don't want to allow generation of these algorithms */
2307     return i;
2308 }
2309
2310 /* 
2311  * Parse the usage parameter and set the keyflags.  Returns -1 on
2312  * error, 0 for no usage given or 1 for usage available.
2313  */
2314 static int
2315 parse_parameter_usage (const char *fname,
2316                        struct para_data_s *para, enum para_name key)
2317 {
2318     struct para_data_s *r = get_parameter( para, key );
2319     char *p, *pn;
2320     unsigned int use;
2321
2322     if( !r )
2323         return 0; /* none (this is an optional parameter)*/
2324     
2325     use = 0;
2326     pn = r->u.value;
2327     while ( (p = strsep (&pn, " \t,")) ) {
2328         if ( !*p)
2329             ;
2330         else if ( !ascii_strcasecmp (p, "sign") )
2331             use |= PUBKEY_USAGE_SIG;
2332         else if ( !ascii_strcasecmp (p, "encrypt") )
2333             use |= PUBKEY_USAGE_ENC;
2334         else if ( !ascii_strcasecmp (p, "auth") )
2335             use |= PUBKEY_USAGE_AUTH;
2336         else {
2337             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2338             return -1; /* error */
2339         }
2340     }
2341     r->u.usage = use;
2342     return 1;
2343 }
2344
2345 static int
2346 parse_revocation_key (const char *fname,
2347                       struct para_data_s *para, enum para_name key)
2348 {
2349   struct para_data_s *r = get_parameter( para, key );
2350   struct revocation_key revkey;
2351   char *pn;
2352   int i;
2353
2354   if( !r )
2355     return 0; /* none (this is an optional parameter) */
2356
2357   pn = r->u.value;
2358
2359   revkey.class=0x80;
2360   revkey.algid=atoi(pn);
2361   if(!revkey.algid)
2362     goto fail;
2363
2364   /* Skip to the fpr */
2365   while(*pn && *pn!=':')
2366     pn++;
2367
2368   if(*pn!=':')
2369     goto fail;
2370
2371   pn++;
2372
2373   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2374     {
2375       int c=hextobyte(pn);
2376       if(c==-1)
2377         goto fail;
2378
2379       revkey.fpr[i]=c;
2380     }
2381
2382   /* skip to the tag */
2383   while(*pn && *pn!='s' && *pn!='S')
2384     pn++;
2385
2386   if(ascii_strcasecmp(pn,"sensitive")==0)
2387     revkey.class|=0x40;
2388
2389   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2390
2391   return 0;
2392
2393   fail:
2394   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2395   return -1; /* error */
2396 }
2397
2398
2399 static u32
2400 get_parameter_u32( struct para_data_s *para, enum para_name key )
2401 {
2402   struct para_data_s *r = get_parameter( para, key );
2403
2404   if( !r )
2405     return 0;
2406   if( r->key == pKEYCREATIONDATE )
2407     return r->u.creation;
2408   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2409     return r->u.expire;
2410   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2411     return r->u.usage;
2412   
2413   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2414 }
2415
2416 static unsigned int
2417 get_parameter_uint( struct para_data_s *para, enum para_name key )
2418 {
2419     return get_parameter_u32( para, key );
2420 }
2421
2422 static DEK *
2423 get_parameter_dek( 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.dek : NULL;
2427 }
2428
2429 static STRING2KEY *
2430 get_parameter_s2k( 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.s2k : NULL;
2434 }
2435
2436 static struct revocation_key *
2437 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2438 {
2439     struct para_data_s *r = get_parameter( para, key );
2440     return r? &r->u.revkey : NULL;
2441 }
2442
2443 static int
2444 proc_parameter_file( struct para_data_s *para, const char *fname,
2445                      struct output_control_s *outctrl, int card )
2446 {
2447   struct para_data_s *r;
2448   const char *s1, *s2, *s3;
2449   size_t n;
2450   char *p;
2451   int have_user_id=0,err,algo;
2452
2453   /* Check that we have all required parameters. */
2454   r = get_parameter( para, pKEYTYPE );
2455   if(r)
2456     {
2457       algo=get_parameter_algo(para,pKEYTYPE);
2458       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2459         {
2460           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2461           return -1;
2462         }
2463     }
2464   else
2465     {
2466       log_error ("%s: no Key-Type specified\n",fname);
2467       return -1;
2468     }
2469
2470   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2471   if (!err)
2472     {
2473       /* Default to algo capabilities if key-usage is not provided */
2474       r = xmalloc_clear(sizeof(*r));
2475       r->key = pKEYUSAGE;
2476       r->u.usage = openpgp_pk_algo_usage(algo);
2477       r->next = para;
2478       para = r;
2479     }
2480   else if (err == -1)
2481     return -1;
2482   else
2483     {
2484       r = get_parameter (para, pKEYUSAGE);
2485       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2486         {
2487           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2488                      fname, r->lnr, algo);
2489           return -1;
2490         }
2491     }
2492
2493   r = get_parameter( para, pSUBKEYTYPE );
2494   if(r)
2495     {
2496       algo = get_parameter_algo (para, pSUBKEYTYPE);
2497       if (openpgp_pk_test_algo (algo))
2498         {
2499           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2500           return -1;
2501         }
2502
2503       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2504       if (!err)
2505         {
2506           /* Default to algo capabilities if subkey-usage is not
2507              provided */
2508           r = xmalloc_clear (sizeof(*r));
2509           r->key = pSUBKEYUSAGE;
2510           r->u.usage = openpgp_pk_algo_usage (algo);
2511           r->next = para;
2512           para = r;
2513         }
2514       else if (err == -1)
2515         return -1;
2516       else
2517         {
2518           r = get_parameter (para, pSUBKEYUSAGE);
2519           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2520             {
2521               log_error ("%s:%d: specified Subkey-Usage not allowed"
2522                          " for algo %d\n", fname, r->lnr, algo);
2523               return -1;
2524             }
2525         }
2526     }
2527
2528
2529   if( get_parameter_value( para, pUSERID ) )
2530     have_user_id=1;
2531   else
2532     {
2533       /* create the formatted user ID */
2534       s1 = get_parameter_value( para, pNAMEREAL );
2535       s2 = get_parameter_value( para, pNAMECOMMENT );
2536       s3 = get_parameter_value( para, pNAMEEMAIL );
2537       if( s1 || s2 || s3 )
2538         {
2539           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2540           r = xmalloc_clear( sizeof *r + n + 20 );
2541           r->key = pUSERID;
2542           p = r->u.value;
2543           if( s1 )
2544             p = stpcpy(p, s1 );
2545           if( s2 )
2546             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2547           if( s3 )
2548             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2549           r->next = para;
2550           para = r;
2551           have_user_id=1;
2552         }
2553     }
2554
2555   if(!have_user_id)
2556     {
2557       log_error("%s: no User-ID specified\n",fname);
2558       return -1;
2559     }
2560
2561   /* Set preferences, if any. */
2562   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2563
2564   /* Set keyserver, if any. */
2565   s1=get_parameter_value( para, pKEYSERVER );
2566   if(s1)
2567     {
2568       struct keyserver_spec *spec;
2569
2570       spec=parse_keyserver_uri(s1,1,NULL,0);
2571       if(spec)
2572         {
2573           free_keyserver_spec(spec);
2574           opt.def_keyserver_url=s1;
2575         }
2576       else
2577         {
2578           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2579           return -1;
2580         }
2581     }
2582
2583   /* Set revoker, if any. */
2584   if (parse_revocation_key (fname, para, pREVOKER))
2585     return -1;
2586
2587   /* Make DEK and S2K from the Passphrase. */
2588   if (outctrl->ask_passphrase)
2589     {
2590       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
2591          feature is required so that GUIs are able to do a key
2592          creation but have gpg-agent ask for the passphrase.  */
2593       int canceled = 0;
2594       STRING2KEY *s2k;
2595       DEK *dek;
2596
2597       dek = do_ask_passphrase (&s2k, 0, &canceled);
2598       if (dek)
2599         {
2600           r = xmalloc_clear( sizeof *r );
2601           r->key = pPASSPHRASE_DEK;
2602           r->u.dek = dek;
2603           r->next = para;
2604           para = r;
2605           r = xmalloc_clear( sizeof *r );
2606           r->key = pPASSPHRASE_S2K;
2607           r->u.s2k = s2k;
2608           r->next = para;
2609           para = r;
2610         }
2611
2612       if (canceled) 
2613         {
2614           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
2615           return -1;
2616         }
2617     }
2618   else
2619     {
2620       r = get_parameter( para, pPASSPHRASE );
2621       if ( r && *r->u.value )
2622         {
2623           /* We have a plain text passphrase - create a DEK from it.
2624            * It is a little bit ridiculous to keep it in secure memory
2625            * but because we do this always, why not here.  */
2626           STRING2KEY *s2k;
2627           DEK *dek;
2628           
2629           s2k = xmalloc_secure ( sizeof *s2k );
2630           s2k->mode = opt.s2k_mode;
2631           s2k->hash_algo = S2K_DIGEST_ALGO;
2632           set_next_passphrase ( r->u.value );
2633           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2634                                    NULL, NULL);
2635           set_next_passphrase (NULL );
2636           assert (dek);
2637           memset (r->u.value, 0, strlen(r->u.value));
2638           
2639           r = xmalloc_clear (sizeof *r);
2640           r->key = pPASSPHRASE_S2K;
2641           r->u.s2k = s2k;
2642           r->next = para;
2643           para = r;
2644           r = xmalloc_clear (sizeof *r);
2645           r->key = pPASSPHRASE_DEK;
2646           r->u.dek = dek;
2647           r->next = para;
2648           para = r;
2649         }
2650     }
2651
2652   /* Make KEYCREATIONDATE from Creation-Date.  */
2653   r = get_parameter (para, pCREATIONDATE);
2654   if (r && *r->u.value)
2655     {
2656       u32 seconds;
2657
2658       seconds = parse_creation_string (r->u.value);
2659       if (!seconds)
2660         {
2661           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
2662           return -1;
2663         }
2664       r->u.creation = seconds;
2665       r->key = pKEYCREATIONDATE;  /* Change that entry. */
2666     }
2667
2668   /* Make KEYEXPIRE from Expire-Date.  */
2669   r = get_parameter( para, pEXPIREDATE );
2670   if( r && *r->u.value )
2671     {
2672       u32 seconds;
2673
2674       seconds = parse_expire_string( r->u.value );
2675       if( seconds == (u32)-1 )
2676         {
2677           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2678           return -1;
2679         }
2680       r->u.expire = seconds;
2681       r->key = pKEYEXPIRE;  /* change hat entry */
2682       /* also set it for the subkey */
2683       r = xmalloc_clear( sizeof *r + 20 );
2684       r->key = pSUBKEYEXPIRE;
2685       r->u.expire = seconds;
2686       r->next = para;
2687       para = r;
2688     }
2689
2690   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2691     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2692     return -1;
2693   }
2694
2695   do_generate_keypair( para, outctrl, card );
2696   return 0;
2697 }
2698
2699
2700 /****************
2701  * Kludge to allow non interactive key generation controlled
2702  * by a parameter file.
2703  * Note, that string parameters are expected to be in UTF-8
2704  */
2705 static void
2706 read_parameter_file( const char *fname )
2707 {
2708     static struct { const char *name;
2709                     enum para_name key;
2710     } keywords[] = {
2711         { "Key-Type",       pKEYTYPE},
2712         { "Key-Length",     pKEYLENGTH },
2713         { "Key-Usage",      pKEYUSAGE },
2714         { "Subkey-Type",    pSUBKEYTYPE },
2715         { "Subkey-Length",  pSUBKEYLENGTH },
2716         { "Subkey-Usage",   pSUBKEYUSAGE },
2717         { "Name-Real",      pNAMEREAL },
2718         { "Name-Email",     pNAMEEMAIL },
2719         { "Name-Comment",   pNAMECOMMENT },
2720         { "Expire-Date",    pEXPIREDATE },
2721         { "Creation-Date",  pCREATIONDATE },
2722         { "Passphrase",     pPASSPHRASE },
2723         { "Preferences",    pPREFERENCES },
2724         { "Revoker",        pREVOKER },
2725         { "Handle",         pHANDLE },
2726         { "Keyserver",      pKEYSERVER },
2727         { NULL, 0 }
2728     };
2729     IOBUF fp;
2730     byte *line;
2731     unsigned int maxlen, nline;
2732     char *p;
2733     int lnr;
2734     const char *err = NULL;
2735     struct para_data_s *para, *r;
2736     int i;
2737     struct output_control_s outctrl;
2738
2739     memset( &outctrl, 0, sizeof( outctrl ) );
2740     outctrl.pub.afx = new_armor_context ();
2741     outctrl.sec.afx = new_armor_context ();
2742
2743     if( !fname || !*fname)
2744       fname = "-";
2745
2746     fp = iobuf_open (fname);
2747     if (fp && is_secured_file (iobuf_get_fd (fp)))
2748       {
2749         iobuf_close (fp);
2750         fp = NULL;
2751         errno = EPERM;
2752       }
2753     if (!fp) {
2754       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2755       return;
2756     }
2757     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2758
2759     lnr = 0;
2760     err = NULL;
2761     para = NULL;
2762     maxlen = 1024;
2763     line = NULL;
2764     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2765         char *keyword, *value;
2766
2767         lnr++;
2768         if( !maxlen ) {
2769             err = "line too long";
2770             break;
2771         }
2772         for( p = line; isspace(*(byte*)p); p++ )
2773             ;
2774         if( !*p || *p == '#' )
2775             continue;
2776         keyword = p;
2777         if( *keyword == '%' ) {
2778             for( ; !isspace(*(byte*)p); p++ )
2779                 ;
2780             if( *p )
2781                 *p++ = 0;
2782             for( ; isspace(*(byte*)p); p++ )
2783                 ;
2784             value = p;
2785             trim_trailing_ws( value, strlen(value) );
2786             if( !ascii_strcasecmp( keyword, "%echo" ) )
2787                 log_info("%s\n", value );
2788             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2789                 outctrl.dryrun = 1;
2790             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
2791                 outctrl.ask_passphrase = 1;
2792             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
2793                 outctrl.ask_passphrase = 0;
2794             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2795                 outctrl.lnr = lnr;
2796                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2797                   print_status_key_not_created 
2798                     (get_parameter_value (para, pHANDLE));
2799                 release_parameter_list( para );
2800                 para = NULL;
2801             }
2802             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2803                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2804                     ; /* still the same file - ignore it */
2805                 else {
2806                     xfree( outctrl.pub.newfname );
2807                     outctrl.pub.newfname = xstrdup( value );
2808                     outctrl.use_files = 1;
2809                 }
2810             }
2811             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2812                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2813                     ; /* still the same file - ignore it */
2814                 else {
2815                    xfree( outctrl.sec.newfname );
2816                    outctrl.sec.newfname = xstrdup( value );
2817                    outctrl.use_files = 1;
2818                 }
2819             }
2820             else
2821                 log_info("skipping control `%s' (%s)\n", keyword, value );
2822
2823
2824             continue;
2825         }
2826
2827
2828         if( !(p = strchr( p, ':' )) || p == keyword ) {
2829             err = "missing colon";
2830             break;
2831         }
2832         if( *p )
2833             *p++ = 0;
2834         for( ; isspace(*(byte*)p); p++ )
2835             ;
2836         if( !*p ) {
2837             err = "missing argument";
2838             break;
2839         }
2840         value = p;
2841         trim_trailing_ws( value, strlen(value) );
2842
2843         for(i=0; keywords[i].name; i++ ) {
2844             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2845                 break;
2846         }
2847         if( !keywords[i].name ) {
2848             err = "unknown keyword";
2849             break;
2850         }
2851         if( keywords[i].key != pKEYTYPE && !para ) {
2852             err = "parameter block does not start with \"Key-Type\"";
2853             break;
2854         }
2855
2856         if( keywords[i].key == pKEYTYPE && para ) {
2857             outctrl.lnr = lnr;
2858             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2859               print_status_key_not_created
2860                 (get_parameter_value (para, pHANDLE));
2861             release_parameter_list( para );
2862             para = NULL;
2863         }
2864         else {
2865             for( r = para; r; r = r->next ) {
2866                 if( r->key == keywords[i].key )
2867                     break;
2868             }
2869             if( r ) {
2870                 err = "duplicate keyword";
2871                 break;
2872             }
2873         }
2874         r = xmalloc_clear( sizeof *r + strlen( value ) );
2875         r->lnr = lnr;
2876         r->key = keywords[i].key;
2877         strcpy( r->u.value, value );
2878         r->next = para;
2879         para = r;
2880     }
2881     if( err )
2882         log_error("%s:%d: %s\n", fname, lnr, err );
2883     else if( iobuf_error (fp) ) {
2884         log_error("%s:%d: read error\n", fname, lnr);
2885     }
2886     else if( para ) {
2887         outctrl.lnr = lnr;
2888         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2889           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2890     }
2891
2892     if( outctrl.use_files ) { /* close open streams */
2893         iobuf_close( outctrl.pub.stream );
2894         iobuf_close( outctrl.sec.stream );
2895
2896         /* Must invalidate that ugly cache to actually close it.  */
2897         if (outctrl.pub.fname)
2898           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2899         if (outctrl.sec.fname)
2900           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2901
2902         xfree( outctrl.pub.fname );
2903         xfree( outctrl.pub.newfname );
2904         xfree( outctrl.sec.fname );
2905         xfree( outctrl.sec.newfname );
2906     }
2907
2908     release_parameter_list( para );
2909     iobuf_close (fp);
2910     release_armor_context (outctrl.pub.afx);
2911     release_armor_context (outctrl.sec.afx);
2912 }
2913
2914
2915 /*
2916  * Generate a keypair (fname is only used in batch mode) If
2917  * CARD_SERIALNO is not NULL the function will create the keys on an
2918  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2919  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2920  * generate in software, imported to the card and a backup file
2921  * written to directory given by this argument .
2922  */
2923 void
2924 generate_keypair (const char *fname, const char *card_serialno, 
2925                   const char *backup_encryption_dir)
2926 {
2927   unsigned int nbits;
2928   char *uid = NULL;
2929   DEK *dek;
2930   STRING2KEY *s2k;
2931   int algo;
2932   unsigned int use;
2933   int both = 0;
2934   u32 expire;
2935   struct para_data_s *para = NULL;
2936   struct para_data_s *r;
2937   struct output_control_s outctrl;
2938   int canceled;
2939   
2940   memset( &outctrl, 0, sizeof( outctrl ) );
2941   
2942   if (opt.batch && card_serialno)
2943     {
2944       /* We don't yet support unattended key generation. */
2945       log_error (_("can't do this in batch mode\n"));
2946       return;
2947     }
2948   
2949   if (opt.batch)
2950     {
2951       read_parameter_file( fname );
2952       return;
2953     }
2954
2955   if (card_serialno)
2956     {
2957 #ifdef ENABLE_CARD_SUPPORT
2958       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2959       r->key = pSERIALNO;
2960       strcpy( r->u.value, card_serialno);
2961       r->next = para;
2962       para = r;
2963        
2964       algo = PUBKEY_ALGO_RSA;
2965        
2966       r = xcalloc (1, sizeof *r + 20 );
2967       r->key = pKEYTYPE;
2968       sprintf( r->u.value, "%d", algo );
2969       r->next = para;
2970       para = r;
2971       r = xcalloc (1, sizeof *r + 20 );
2972       r->key = pKEYUSAGE;
2973       strcpy (r->u.value, "sign");
2974       r->next = para;
2975       para = r;
2976        
2977       r = xcalloc (1, sizeof *r + 20 );
2978       r->key = pSUBKEYTYPE;
2979       sprintf( r->u.value, "%d", algo );
2980       r->next = para;
2981       para = r;
2982       r = xcalloc (1, sizeof *r + 20 );
2983       r->key = pSUBKEYUSAGE;
2984       strcpy (r->u.value, "encrypt");
2985       r->next = para;
2986       para = r;
2987        
2988       r = xcalloc (1, sizeof *r + 20 );
2989       r->key = pAUTHKEYTYPE;
2990       sprintf( r->u.value, "%d", algo );
2991       r->next = para;
2992       para = r;
2993
2994       if (backup_encryption_dir)
2995         {
2996           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2997           r->key = pBACKUPENCDIR;
2998           strcpy (r->u.value, backup_encryption_dir);
2999           r->next = para;
3000           para = r;
3001         }
3002 #endif /*ENABLE_CARD_SUPPORT*/
3003     }
3004   else
3005     {
3006       algo = ask_algo( 0, &use );
3007       if( !algo )
3008         { /* default: DSA with ElG subkey of the specified size */
3009           both = 1;
3010           r = xmalloc_clear( sizeof *r + 20 );
3011           r->key = pKEYTYPE;
3012           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
3013           r->next = para;
3014           para = r;
3015           nbits = ask_keysize( PUBKEY_ALGO_DSA );
3016           r = xmalloc_clear( sizeof *r + 20 );
3017           r->key = pKEYLENGTH;
3018           sprintf( r->u.value, "%u", nbits);
3019           r->next = para;
3020           para = r;
3021           r = xmalloc_clear( sizeof *r + 20 );
3022           r->key = pKEYUSAGE;
3023           strcpy( r->u.value, "sign" );
3024           r->next = para;
3025           para = r;
3026            
3027           algo = PUBKEY_ALGO_ELGAMAL_E;
3028           r = xmalloc_clear( sizeof *r + 20 );
3029           r->key = pSUBKEYTYPE;
3030           sprintf( r->u.value, "%d", algo );
3031           r->next = para;
3032           para = r;
3033           r = xmalloc_clear( sizeof *r + 20 );
3034           r->key = pSUBKEYUSAGE;
3035           strcpy( r->u.value, "encrypt" );
3036           r->next = para;
3037           para = r;
3038         }
3039       else 
3040         {
3041           r = xmalloc_clear( sizeof *r + 20 );
3042           r->key = pKEYTYPE;
3043           sprintf( r->u.value, "%d", algo );
3044           r->next = para;
3045           para = r;
3046            
3047           if (use)
3048             {
3049               r = xmalloc_clear( sizeof *r + 25 );
3050               r->key = pKEYUSAGE;
3051               sprintf( r->u.value, "%s%s%s",
3052                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3053                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3054                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3055               r->next = para;
3056               para = r;
3057             }
3058            
3059         }
3060
3061       nbits = ask_keysize( algo );
3062       r = xmalloc_clear( sizeof *r + 20 );
3063       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3064       sprintf( r->u.value, "%u", nbits);
3065       r->next = para;
3066       para = r;
3067     }
3068    
3069   expire = ask_expire_interval(0,NULL);
3070   r = xmalloc_clear( sizeof *r + 20 );
3071   r->key = pKEYEXPIRE;
3072   r->u.expire = expire;
3073   r->next = para;
3074   para = r;
3075   r = xmalloc_clear( sizeof *r + 20 );
3076   r->key = pSUBKEYEXPIRE;
3077   r->u.expire = expire;
3078   r->next = para;
3079   para = r;
3080
3081   uid = ask_user_id(0);
3082   if( !uid ) 
3083     {
3084       log_error(_("Key generation canceled.\n"));
3085       release_parameter_list( para );
3086       return;
3087     }
3088   r = xmalloc_clear( sizeof *r + strlen(uid) );
3089   r->key = pUSERID;
3090   strcpy( r->u.value, uid );
3091   r->next = para;
3092   para = r;
3093     
3094   canceled = 0;
3095   dek = card_serialno? NULL : do_ask_passphrase (&s2k, 0, &canceled);
3096   if( dek )
3097     {
3098       r = xmalloc_clear( sizeof *r );
3099       r->key = pPASSPHRASE_DEK;
3100       r->u.dek = dek;
3101       r->next = para;
3102       para = r;
3103       r = xmalloc_clear( sizeof *r );
3104       r->key = pPASSPHRASE_S2K;
3105       r->u.s2k = s2k;
3106       r->next = para;
3107       para = r;
3108     }
3109
3110   if (canceled) 
3111     log_error (_("Key generation canceled.\n"));
3112   else
3113     proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3114   release_parameter_list( para );
3115 }
3116
3117
3118 #ifdef ENABLE_CARD_SUPPORT
3119 /* Generate a raw key and return it as a secret key packet.  The
3120    function will ask for the passphrase and return a protected as well
3121    as an unprotected copy of a new secret key packet.  0 is returned
3122    on success and the caller must then free the returned values.  */
3123 static int
3124 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3125                   PKT_secret_key **r_sk_unprotected,
3126                   PKT_secret_key **r_sk_protected)
3127 {
3128   int rc;
3129   DEK *dek = NULL;
3130   STRING2KEY *s2k = NULL;
3131   PKT_secret_key *sk = NULL;
3132   int i;
3133   size_t nskey, npkey;
3134   gcry_sexp_t s_parms, s_key;
3135   int canceled;
3136
3137   npkey = pubkey_get_npkey (algo);
3138   nskey = pubkey_get_nskey (algo);
3139   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3140
3141   if (nbits < 512)
3142     {
3143       nbits = 512;
3144       log_info (_("keysize invalid; using %u bits\n"), nbits );
3145     }
3146
3147   if ((nbits % 32)) 
3148     {
3149       nbits = ((nbits + 31) / 32) * 32;
3150       log_info(_("keysize rounded up to %u bits\n"), nbits );
3151     }
3152
3153   dek = do_ask_passphrase (&s2k, 1, &canceled);
3154   if (canceled)
3155     {
3156       rc = gpg_error (GPG_ERR_CANCELED);
3157       goto leave;
3158     }
3159
3160   sk = xmalloc_clear (sizeof *sk);
3161   sk->timestamp = created_at;
3162   sk->version = 4;
3163   sk->pubkey_algo = algo;
3164
3165   if ( !is_RSA (algo) )
3166     {
3167       log_error ("only RSA is supported for offline generated keys\n");
3168       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3169       goto leave;
3170     }
3171   rc = gcry_sexp_build (&s_parms, NULL,
3172                         "(genkey(rsa(nbits %d)))",
3173                         (int)nbits);
3174   if (rc)
3175     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3176   rc = gcry_pk_genkey (&s_key, s_parms);
3177   gcry_sexp_release (s_parms);
3178   if (rc)
3179     {
3180       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3181       goto leave;
3182     }
3183   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3184   gcry_sexp_release (s_key);
3185   if (rc) 
3186     {
3187       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3188       goto leave;
3189     }
3190   
3191   for (i=npkey; i < nskey; i++)
3192     sk->csum += checksum_mpi (sk->skey[i]);
3193
3194   if (r_sk_unprotected) 
3195     *r_sk_unprotected = copy_secret_key (NULL, sk);
3196
3197   rc = genhelp_protect (dek, s2k, sk);
3198   if (rc)
3199     goto leave;
3200
3201   if (r_sk_protected)
3202     {
3203       *r_sk_protected = sk;
3204       sk = NULL;
3205     }
3206
3207  leave:
3208   if (sk)
3209     free_secret_key (sk);
3210   xfree (dek);
3211   xfree (s2k);
3212   return rc;
3213 }
3214 #endif /* ENABLE_CARD_SUPPORT */
3215
3216 /* Create and delete a dummy packet to start off a list of kbnodes. */
3217 static void
3218 start_tree(KBNODE *tree)
3219 {
3220   PACKET *pkt;
3221
3222   pkt=xmalloc_clear(sizeof(*pkt));
3223   pkt->pkttype=PKT_NONE;
3224   *tree=new_kbnode(pkt);
3225   delete_kbnode(*tree);
3226 }
3227
3228
3229 static void
3230 do_generate_keypair (struct para_data_s *para,
3231                      struct output_control_s *outctrl, int card)
3232 {
3233   KBNODE pub_root = NULL;
3234   KBNODE sec_root = NULL;
3235   PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3236   const char *s;
3237   struct revocation_key *revkey;
3238   int rc;
3239   int did_sub = 0;
3240   u32 timestamp;
3241
3242   if( outctrl->dryrun )
3243     {
3244       log_info("dry-run mode - key generation skipped\n");
3245       return;
3246     }
3247   
3248   if ( outctrl->use_files ) 
3249     {
3250       if ( outctrl->pub.newfname ) 
3251         {
3252           iobuf_close(outctrl->pub.stream);
3253           outctrl->pub.stream = NULL;
3254           if (outctrl->pub.fname)
3255             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
3256           xfree( outctrl->pub.fname );
3257           outctrl->pub.fname =  outctrl->pub.newfname;
3258           outctrl->pub.newfname = NULL;
3259           
3260           if (is_secured_filename (outctrl->pub.fname) ) 
3261             {
3262               outctrl->pub.stream = NULL;
3263               errno = EPERM;
3264             }
3265           else
3266             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3267           if (!outctrl->pub.stream)
3268             {
3269               log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3270                         strerror(errno) );
3271               return;
3272             }
3273           if (opt.armor)
3274             {
3275               outctrl->pub.afx->what = 1;
3276               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3277             }
3278         }
3279       if (outctrl->sec.newfname)
3280         {
3281           mode_t oldmask;
3282           
3283           iobuf_close(outctrl->sec.stream);
3284           outctrl->sec.stream = NULL;
3285           if (outctrl->sec.fname)
3286             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3287           xfree( outctrl->sec.fname );
3288           outctrl->sec.fname =  outctrl->sec.newfname;
3289           outctrl->sec.newfname = NULL;
3290
3291           oldmask = umask (077);
3292           if (is_secured_filename (outctrl->sec.fname) )
3293             {
3294               outctrl->sec.stream = NULL;
3295               errno = EPERM;
3296             }
3297           else
3298             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3299           umask (oldmask);
3300           if (!outctrl->sec.stream)
3301             {
3302               log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3303                         strerror(errno) );
3304               return;
3305             }
3306           if (opt.armor)
3307             {
3308               outctrl->sec.afx->what = 5;
3309               push_armor_filter (outctrl->sec.afx, outctrl->sec.stream);
3310             }
3311         }
3312       assert( outctrl->pub.stream );
3313       assert( outctrl->sec.stream );
3314       if (opt.verbose)
3315         {
3316           log_info (_("writing public key to `%s'\n"), outctrl->pub.fname );
3317           if (card)
3318             log_info (_("writing secret key stub to `%s'\n"),
3319                       outctrl->sec.fname);
3320           else
3321             log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3322         }
3323     }
3324
3325
3326   /* We create the packets as a tree of kbnodes.  Because the
3327      structure we create is known in advance we simply generate a
3328      linked list.  The first packet is a dummy packet which we flag as
3329      deleted.  The very first packet must always be a KEY packet.  */
3330     
3331   start_tree (&pub_root);
3332   start_tree (&sec_root);
3333
3334   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3335   if (!timestamp)
3336     timestamp = make_timestamp ();
3337
3338   if (!card)
3339     {
3340       rc = do_create (get_parameter_algo( para, pKEYTYPE ),
3341                       get_parameter_uint( para, pKEYLENGTH ),
3342                       pub_root, sec_root,
3343                       get_parameter_dek( para, pPASSPHRASE_DEK ),
3344                       get_parameter_s2k( para, pPASSPHRASE_S2K ),
3345                       &pri_sk,
3346                       timestamp,
3347                       get_parameter_u32( para, pKEYEXPIRE ), 0 );
3348     }
3349   else
3350     {
3351       /* Note, that depending on the backend, the card key generation
3352          may update TIMESTAMP.  */
3353       rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root, NULL,
3354                          &timestamp,
3355                          get_parameter_u32 (para, pKEYEXPIRE), para);
3356       if (!rc)
3357         {
3358           pri_sk = sec_root->next->pkt->pkt.secret_key;
3359           assert (pri_sk);
3360         }
3361     }
3362
3363   if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3364     {
3365       rc = write_direct_sig (pub_root, pub_root, pri_sk, revkey, timestamp);
3366       if (!rc)
3367         rc = write_direct_sig (sec_root, pub_root, pri_sk, revkey, timestamp);
3368     }
3369
3370   if( !rc && (s=get_parameter_value(para, pUSERID)) )
3371     {
3372       write_uid (pub_root, s );
3373       write_uid (sec_root, s );
3374
3375       rc = write_selfsigs (sec_root, pub_root, pri_sk,
3376                            get_parameter_uint (para, pKEYUSAGE), timestamp);
3377     }
3378
3379   /* Write the auth key to the card before the encryption key.  This
3380      is a partial workaround for a PGP bug (as of this writing, all
3381      versions including 8.1), that causes it to try and encrypt to
3382      the most recent subkey regardless of whether that subkey is
3383      actually an encryption type.  In this case, the auth key is an
3384      RSA key so it succeeds. */
3385
3386   if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3387     {
3388       /* Note, that depending on the backend, the card key generation
3389          may update TIMESTAMP.  */
3390       rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root, NULL,
3391                          &timestamp,
3392                          get_parameter_u32 (para, pKEYEXPIRE), para);
3393         
3394       if (!rc)
3395         rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk,
3396                                PUBKEY_USAGE_AUTH, timestamp);
3397       if (!rc)
3398         rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk,
3399                                PUBKEY_USAGE_AUTH, timestamp);
3400     }
3401
3402   if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3403     {
3404       if (!card)
3405         {
3406           rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
3407                           get_parameter_uint( para, pSUBKEYLENGTH ),
3408                           pub_root, sec_root,
3409                           get_parameter_dek( para, pPASSPHRASE_DEK ),
3410                           get_parameter_s2k( para, pPASSPHRASE_S2K ),
3411                           &sub_sk,
3412                           timestamp,
3413                           get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3414         }
3415       else
3416         {
3417           if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3418             {
3419               /* A backup of the encryption key has been requested.
3420                  Generate the key in software and import it then to
3421                  the card.  Write a backup file. */
3422               rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3423                                              pub_root, sec_root,
3424                                              timestamp,
3425                                              get_parameter_u32 (para,
3426                                                                 pKEYEXPIRE),
3427                                              para, s);
3428             }
3429           else
3430             {
3431               /* Note, that depending on the backend, the card key
3432                  generation may update TIMESTAMP.  */
3433               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3434                                  NULL,
3435                                  &timestamp,
3436                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3437             }
3438         }
3439
3440       if( !rc )
3441         rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
3442                               get_parameter_uint (para, pSUBKEYUSAGE),
3443                               timestamp);
3444       if( !rc )
3445         rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
3446                               get_parameter_uint (para, pSUBKEYUSAGE),
3447                               timestamp);
3448       did_sub = 1;
3449     }
3450
3451   if (!rc && outctrl->use_files)  /* Direct write to specified files.  */
3452     {
3453       rc = write_keyblock( outctrl->pub.stream, pub_root );
3454       if (rc)
3455         log_error ("can't write public key: %s\n", g10_errstr(rc) );
3456       if (!rc) 
3457         {
3458           rc = write_keyblock( outctrl->sec.stream, sec_root );
3459           if(rc)
3460             log_error ("can't write secret key: %s\n", g10_errstr(rc) );
3461         }
3462     }
3463   else if (!rc) /* Write to the standard keyrings.  */
3464     {
3465       KEYDB_HANDLE pub_hd = keydb_new (0);
3466       KEYDB_HANDLE sec_hd = keydb_new (1);
3467
3468       rc = keydb_locate_writable (pub_hd, NULL);
3469       if (rc) 
3470         log_error (_("no writable public keyring found: %s\n"),
3471                    g10_errstr (rc));
3472
3473       if (!rc) 
3474         {  
3475           rc = keydb_locate_writable (sec_hd, NULL);
3476           if (rc) 
3477             log_error (_("no writable secret keyring found: %s\n"),
3478                        g10_errstr (rc));
3479         }
3480       
3481       if (!rc && opt.verbose)
3482         {
3483           log_info (_("writing public key to `%s'\n"),
3484                     keydb_get_resource_name (pub_hd));
3485           if (card)
3486             log_info (_("writing secret key stub to `%s'\n"),
3487                       keydb_get_resource_name (sec_hd));
3488           else
3489             log_info (_("writing secret key to `%s'\n"),
3490                       keydb_get_resource_name (sec_hd));
3491         }
3492       
3493       if (!rc) 
3494         {
3495           rc = keydb_insert_keyblock (pub_hd, pub_root);
3496           if (rc)
3497             log_error (_("error writing public keyring `%s': %s\n"),
3498                        keydb_get_resource_name (pub_hd), g10_errstr(rc));
3499         }
3500       
3501       if (!rc)
3502         {
3503           rc = keydb_insert_keyblock (sec_hd, sec_root);
3504           if (rc)
3505             log_error (_("error writing secret keyring `%s': %s\n"),
3506                        keydb_get_resource_name (pub_hd), g10_errstr(rc));
3507         }
3508
3509       keydb_release (pub_hd);
3510       keydb_release (sec_hd);
3511       
3512       if (!rc)
3513         {
3514           int no_enc_rsa;
3515           PKT_public_key *pk;
3516
3517           no_enc_rsa = (get_parameter_algo (para, pKEYTYPE) == PUBKEY_ALGO_RSA
3518                         && get_parameter_uint (para, pKEYUSAGE)
3519                         && !((get_parameter_uint (para, pKEYUSAGE)
3520                               & PUBKEY_USAGE_ENC)) );
3521
3522           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3523
3524           keyid_from_pk(pk,pk->main_keyid);
3525           register_trusted_keyid(pk->main_keyid);
3526
3527           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
3528                                   | TRUST_ULTIMATE ));
3529
3530           if (!opt.batch) 
3531             {
3532               tty_printf (_("public and secret key created and signed.\n") );
3533               tty_printf ("\n");
3534               list_keyblock(pub_root,0,1,NULL);
3535             }
3536             
3537           
3538           if (!opt.batch
3539               && (get_parameter_algo (para, pKEYTYPE) == PUBKEY_ALGO_DSA
3540                   || no_enc_rsa )
3541               && !get_parameter (para, pSUBKEYTYPE) )
3542             {
3543               tty_printf(_("Note that this key cannot be used for "
3544                            "encryption.  You may want to use\n"
3545                            "the command \"--edit-key\" to generate a "
3546                            "subkey for this purpose.\n") );
3547             }
3548         }
3549     }
3550
3551   if (rc)
3552     {
3553       if (opt.batch)
3554         log_error ("key generation failed: %s\n", g10_errstr(rc) );
3555       else
3556         tty_printf (_("Key generation failed: %s\n"), g10_errstr(rc) );
3557       write_status_error (card? "card_key_generate":"key_generate", rc);
3558       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3559     }
3560   else
3561     {
3562       PKT_public_key *pk = find_kbnode (pub_root, 
3563                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3564       print_status_key_created (did_sub? 'B':'P', pk,
3565                                 get_parameter_value (para, pHANDLE));
3566     }
3567   release_kbnode( pub_root );
3568   release_kbnode( sec_root );
3569   
3570   if (pri_sk && !card)        /* The unprotected secret key unless we */
3571     free_secret_key (pri_sk); /* have a shallow copy in card mode. */
3572   if (sub_sk)
3573     free_secret_key(sub_sk);
3574 }
3575
3576
3577 /* Add a new subkey to an existing key.  Returns true if a new key has
3578    been generated and put into the keyblocks.  */
3579 int
3580 generate_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock)
3581 {
3582   int okay=0, rc=0;
3583   KBNODE node;
3584   PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3585   int algo;
3586   unsigned int use;
3587   u32 expire;
3588   unsigned nbits;
3589   char *passphrase = NULL;
3590   DEK *dek = NULL;
3591   STRING2KEY *s2k = NULL;
3592   u32 cur_time;
3593   int ask_pass = 0;
3594   int canceled;
3595
3596   /* Break out the primary secret key.  */
3597   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3598   if( !node ) 
3599     {
3600       log_error ("Oops; secret key not found anymore!\n");
3601       goto leave;
3602     }
3603   
3604   /* Make a copy of the sk to keep the protected one in the keyblock. */
3605   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3606
3607   cur_time = make_timestamp();
3608
3609   if (pri_sk->timestamp > cur_time)
3610     {
3611       ulong d = pri_sk->timestamp - cur_time;
3612       log_info ( d==1 ? _("key has been created %lu second "
3613                           "in future (time warp or clock problem)\n")
3614                  : _("key has been created %lu seconds "
3615                      "in future (time warp or clock problem)\n"), d );
3616       if (!opt.ignore_time_conflict)
3617         {
3618           rc = G10ERR_TIME_CONFLICT;
3619           goto leave;
3620         }
3621     }
3622
3623   if (pri_sk->version < 4) 
3624     {
3625       log_info (_("NOTE: creating subkeys for v3 keys "
3626                   "is not OpenPGP compliant\n"));
3627       goto leave;
3628     }
3629
3630   if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001)
3631     {
3632       tty_printf (_("Secret parts of primary key are not available.\n"));
3633       rc = G10ERR_NO_SECKEY;
3634       goto leave;
3635     }
3636
3637
3638   /* Unprotect to get the passphrase.  */
3639   switch (is_secret_key_protected (pri_sk) )
3640     {
3641     case -1:
3642       rc = G10ERR_PUBKEY_ALGO;
3643       break;
3644     case 0:
3645       tty_printf (_("This key is not protected.\n"));
3646       break;
3647     case -2:
3648       tty_printf (_("Secret parts of primary key are stored on-card.\n"));
3649       ask_pass = 1;
3650       break;
3651     default:
3652       tty_printf (_("Key is protected.\n"));
3653       rc = check_secret_key ( pri_sk, 0 );
3654       if (!rc)
3655         passphrase = get_last_passphrase();
3656       break;
3657     }
3658   if (rc)
3659     goto leave;
3660
3661   algo = ask_algo (1, &use);
3662   assert (algo);
3663   nbits = ask_keysize (algo);
3664   expire = ask_expire_interval (0, NULL);
3665   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3666                                                _("Really create? (y/N) ")))
3667     goto leave;
3668   
3669   canceled = 0;
3670   if (ask_pass)
3671     dek = do_ask_passphrase (&s2k, 0, &canceled);
3672   else if (passphrase)
3673     {
3674       s2k = xmalloc_secure ( sizeof *s2k );
3675       s2k->mode = opt.s2k_mode;
3676       s2k->hash_algo = S2K_DIGEST_ALGO;
3677       set_next_passphrase ( passphrase );
3678       dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3679                                NULL, NULL );
3680     }
3681   
3682   if (canceled)
3683     rc = GPG_ERR_CANCELED;
3684   
3685   if (!rc)
3686     rc = do_create (algo, nbits, pub_keyblock, sec_keyblock,
3687                     dek, s2k, &sub_sk, cur_time, expire, 1 );
3688   if (!rc)
3689     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, 
3690                           use, cur_time);
3691   if (!rc)
3692     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, 
3693                            use, cur_time);
3694   if (!rc) 
3695     {
3696       okay = 1;
3697       write_status_text (STATUS_KEY_CREATED, "S");
3698     }
3699
3700  leave:
3701   if (rc)
3702     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3703   xfree (passphrase);
3704   xfree (dek);
3705   xfree (s2k);
3706   /* Release the copy of the (now unprotected) secret keys.  */
3707   if (pri_sk)
3708     free_secret_key (pri_sk);
3709   if (sub_sk)
3710     free_secret_key (sub_sk);
3711   set_next_passphrase (NULL);
3712   return okay;
3713 }
3714
3715
3716 #ifdef ENABLE_CARD_SUPPORT
3717 /* Generate a subkey on a card. */
3718 int
3719 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3720                           int keyno, const char *serialno)
3721 {
3722   int okay=0, rc=0;
3723   KBNODE node;
3724   PKT_secret_key *pri_sk = NULL, *sub_sk;
3725   int algo;
3726   unsigned int use;
3727   u32 expire;
3728   char *passphrase = NULL;
3729   u32 cur_time;
3730   struct para_data_s *para = NULL;
3731
3732   assert (keyno >= 1 && keyno <= 3);
3733
3734   para = xcalloc (1, sizeof *para + strlen (serialno) );
3735   para->key = pSERIALNO;
3736   strcpy (para->u.value, serialno);
3737
3738   /* Break out the primary secret key */
3739   node = find_kbnode (sec_keyblock, PKT_SECRET_KEY);
3740   if (!node)
3741     {
3742       log_error("Oops; secret key not found anymore!\n");
3743       goto leave;
3744     }
3745
3746   /* Make a copy of the sk to keep the protected one in the keyblock */
3747   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3748
3749   cur_time = make_timestamp();
3750   if (pri_sk->timestamp > cur_time)
3751     {
3752       ulong d = pri_sk->timestamp - cur_time;
3753       log_info (d==1 ? _("key has been created %lu second "
3754                          "in future (time warp or clock problem)\n")
3755                      : _("key has been created %lu seconds "
3756                          "in future (time warp or clock problem)\n"), d );
3757         if (!opt.ignore_time_conflict)
3758           {
3759             rc = G10ERR_TIME_CONFLICT;
3760             goto leave;
3761           }
3762     }
3763
3764   if (pri_sk->version < 4)
3765     {
3766       log_info (_("NOTE: creating subkeys for v3 keys "
3767                   "is not OpenPGP compliant\n"));
3768       goto leave;
3769     }
3770
3771   /* Unprotect to get the passphrase. */
3772   switch( is_secret_key_protected (pri_sk) )
3773     {
3774     case -1:
3775       rc = G10ERR_PUBKEY_ALGO;
3776       break;
3777     case 0:
3778       tty_printf("This key is not protected.\n");
3779       break;
3780     default:
3781       tty_printf("Key is protected.\n");
3782       rc = check_secret_key( pri_sk, 0 );
3783       if (!rc)
3784         passphrase = get_last_passphrase();
3785       break;
3786     }
3787   if (rc)
3788     goto leave;
3789
3790   algo = PUBKEY_ALGO_RSA;
3791   expire = ask_expire_interval (0,NULL);
3792   if (keyno == 1)
3793     use = PUBKEY_USAGE_SIG;
3794   else if (keyno == 2)
3795     use = PUBKEY_USAGE_ENC;
3796   else
3797     use = PUBKEY_USAGE_AUTH;
3798   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3799                                                _("Really create? (y/N) ")))
3800     goto leave;
3801
3802   if (passphrase)
3803     set_next_passphrase (passphrase);
3804
3805   /* Note, that depending on the backend, the card key generation may
3806      update CUR_TIME.  */
3807   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock,
3808                      &sub_sk, &cur_time, expire, para);
3809   if (!rc)
3810     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, 
3811                            use, cur_time);
3812   if (!rc)
3813     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, 
3814                            use, cur_time);
3815   if (!rc)
3816     {
3817       okay = 1;
3818       write_status_text (STATUS_KEY_CREATED, "S");
3819     }
3820
3821  leave:
3822   if (rc)
3823     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3824   xfree (passphrase);
3825   /* Release the copy of the (now unprotected) secret keys. */
3826   if (pri_sk)
3827     free_secret_key (pri_sk);
3828   set_next_passphrase( NULL );
3829   release_parameter_list (para);
3830   return okay;
3831 }
3832 #endif /* !ENABLE_CARD_SUPPORT */
3833
3834
3835 /*
3836  * Write a keyblock to an output stream
3837  */
3838 static int
3839 write_keyblock( IOBUF out, KBNODE node )
3840 {
3841   for( ; node ; node = node->next )
3842     {
3843       if(!is_deleted_kbnode(node))
3844         {
3845           int rc = build_packet( out, node->pkt );
3846           if( rc )
3847             {
3848               log_error("build_packet(%d) failed: %s\n",
3849                         node->pkt->pkttype, g10_errstr(rc) );
3850               return rc;
3851             }
3852         }
3853     }
3854
3855   return 0;
3856 }
3857
3858
3859 /* Note that timestamp is an in/out arg. */
3860 static int
3861 gen_card_key (int algo, int keyno, int is_primary,
3862               KBNODE pub_root, KBNODE sec_root, PKT_secret_key **ret_sk,
3863               u32 *timestamp, u32 expireval, struct para_data_s *para)
3864 {
3865 #ifdef ENABLE_CARD_SUPPORT
3866   int rc;
3867   const char *s;
3868   struct agent_card_genkey_s info;
3869   PACKET *pkt;
3870   PKT_secret_key *sk;
3871   PKT_public_key *pk;
3872
3873   assert (algo == PUBKEY_ALGO_RSA);
3874   
3875   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
3876   rc = agent_scd_genkey (&info, keyno, 1, NULL, *timestamp);
3877 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3878 /*      { */
3879 /*        tty_printf ("\n"); */
3880 /*        log_error ("WARNING: key does already exists!\n"); */
3881 /*        tty_printf ("\n"); */
3882 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3883 /*                                    _("Replace existing key? "))) */
3884 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3885 /*      } */
3886
3887   if (rc)
3888     {
3889       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3890       return rc;
3891     }
3892   if ( !info.n || !info.e )
3893     {
3894       log_error ("communication error with SCD\n");
3895       gcry_mpi_release (info.n);
3896       gcry_mpi_release (info.e);
3897       return gpg_error (GPG_ERR_GENERAL);
3898     }
3899   
3900   if (*timestamp != info.created_at)
3901     log_info ("Note that the key does not use the suggested creation date\n");
3902   *timestamp = info.created_at;
3903
3904   pk = xcalloc (1, sizeof *pk );
3905   sk = xcalloc (1, sizeof *sk );
3906   sk->timestamp = pk->timestamp = info.created_at;
3907   sk->version = pk->version = 4;
3908   if (expireval)
3909       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3910   sk->pubkey_algo = pk->pubkey_algo = algo;
3911   pk->pkey[0] = info.n;
3912   pk->pkey[1] = info.e; 
3913   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
3914   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
3915   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3916   sk->is_protected = 1;
3917   sk->protect.s2k.mode = 1002;
3918   s = get_parameter_value (para, pSERIALNO);
3919   if (s)
3920     {
3921       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3922            sk->protect.ivlen++, s += 2)
3923         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3924     }
3925
3926   if( ret_sk )
3927     *ret_sk = sk;
3928
3929   pkt = xcalloc (1,sizeof *pkt);
3930   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3931   pkt->pkt.public_key = pk;
3932   add_kbnode(pub_root, new_kbnode( pkt ));
3933
3934   pkt = xcalloc (1,sizeof *pkt);
3935   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3936   pkt->pkt.secret_key = sk;
3937   add_kbnode(sec_root, new_kbnode( pkt ));
3938
3939   return 0;
3940 #else
3941   return -1;
3942 #endif /*!ENABLE_CARD_SUPPORT*/
3943 }
3944
3945
3946
3947 static int
3948 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3949                           KBNODE pub_root, KBNODE sec_root,
3950                           u32 timestamp,
3951                           u32 expireval, struct para_data_s *para,
3952                           const char *backup_dir)
3953 {
3954 #ifdef ENABLE_CARD_SUPPORT
3955   int rc;
3956   const char *s;
3957   PACKET *pkt;
3958   PKT_secret_key *sk, *sk_unprotected = NULL, *sk_protected = NULL;
3959   PKT_public_key *pk;
3960   size_t n;
3961   int i;
3962   unsigned int nbits;
3963     
3964   /* Get the size of the key directly from the card.  */
3965   {
3966     struct agent_card_info_s info;
3967     
3968     memset (&info, 0, sizeof info);
3969     if (!agent_scd_getattr ("KEY-ATTR", &info)
3970         && info.key_attr[1].algo)
3971       nbits = info.key_attr[1].nbits;
3972     else
3973       nbits = 1024; /* All pre-v2.0 cards.  */
3974     agent_release_card_info (&info);
3975   }
3976
3977   /* Create a key of this size in memory.  */
3978   rc = generate_raw_key (algo, nbits, timestamp,
3979                          &sk_unprotected, &sk_protected);
3980   if (rc)
3981     return rc;
3982
3983   /* Store the key to the card. */
3984   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3985   if (rc)
3986     {
3987       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3988       free_secret_key (sk_unprotected);
3989       free_secret_key (sk_protected);
3990       write_status_error ("save_key_to_card", rc);
3991       return rc;
3992     }
3993
3994   /* Get rid of the secret key parameters and store the serial numer. */
3995   sk = sk_unprotected;
3996   n = pubkey_get_nskey (sk->pubkey_algo);
3997   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3998     {
3999       gcry_mpi_release (sk->skey[i]);
4000       sk->skey[i] = NULL;
4001     }
4002   i = pubkey_get_npkey (sk->pubkey_algo);
4003   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
4004   sk->is_protected = 1;
4005   sk->protect.s2k.mode = 1002;
4006   s = get_parameter_value (para, pSERIALNO);
4007   assert (s);
4008   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
4009        sk->protect.ivlen++, s += 2)
4010     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
4011
4012   /* Now write the *protected* secret key to the file.  */
4013   {
4014     char name_buffer[50];
4015     char *fname;
4016     IOBUF fp;
4017     mode_t oldmask;
4018
4019     keyid_from_sk (sk, NULL);
4020     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
4021              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
4022
4023     fname = make_filename (backup_dir, name_buffer, NULL);
4024     oldmask = umask (077);
4025     if (is_secured_filename (fname))
4026       {
4027         fp = NULL;
4028         errno = EPERM;
4029       }
4030     else
4031       fp = iobuf_create (fname);
4032     umask (oldmask);
4033     if (!fp) 
4034       {
4035         rc = gpg_error_from_syserror ();
4036         log_error (_("can't create backup file `%s': %s\n"),
4037                    fname, strerror(errno) );
4038         xfree (fname);
4039         free_secret_key (sk_unprotected);
4040         free_secret_key (sk_protected);
4041         return rc;
4042       }
4043
4044     pkt = xcalloc (1, sizeof *pkt);
4045     pkt->pkttype = PKT_SECRET_KEY;
4046     pkt->pkt.secret_key = sk_protected;
4047     sk_protected = NULL;
4048
4049     rc = build_packet (fp, pkt);
4050     if (rc)
4051       {
4052         log_error("build packet failed: %s\n", g10_errstr(rc) );
4053         iobuf_cancel (fp);
4054       }
4055     else
4056       {
4057         unsigned char array[MAX_FINGERPRINT_LEN];
4058         char *fprbuf, *p;
4059        
4060         iobuf_close (fp);
4061         iobuf_ioctl (NULL, 2, 0, (char*)fname);
4062         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
4063
4064         fingerprint_from_sk (sk, array, &n);
4065         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
4066         for (i=0; i < n ; i++, p += 2)
4067           sprintf (p, "%02X", array[i]);
4068         *p++ = ' ';
4069         *p = 0;
4070
4071         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
4072                                       fprbuf,
4073                                       fname, strlen (fname),
4074                                       0);
4075         xfree (fprbuf);
4076       }
4077     free_packet (pkt);
4078     xfree (pkt);
4079     xfree (fname);
4080     if (rc)
4081       {
4082         free_secret_key (sk_unprotected);
4083         return rc;
4084       }
4085   }
4086
4087   /* Create the public key from the secret key. */
4088   pk = xcalloc (1, sizeof *pk );
4089   pk->timestamp = sk->timestamp;
4090   pk->version = sk->version;
4091   if (expireval)
4092       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
4093   pk->pubkey_algo = sk->pubkey_algo;
4094   n = pubkey_get_npkey (sk->pubkey_algo);
4095   for (i=0; i < n; i++)
4096     pk->pkey[i] = mpi_copy (sk->skey[i]);
4097
4098   /* Build packets and add them to the node lists.  */
4099   pkt = xcalloc (1,sizeof *pkt);
4100   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
4101   pkt->pkt.public_key = pk;
4102   add_kbnode(pub_root, new_kbnode( pkt ));
4103
4104   pkt = xcalloc (1,sizeof *pkt);
4105   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
4106   pkt->pkt.secret_key = sk;
4107   add_kbnode(sec_root, new_kbnode( pkt ));
4108
4109   return 0;
4110 #else
4111   return -1;
4112 #endif /*!ENABLE_CARD_SUPPORT*/
4113 }
4114
4115
4116 #ifdef ENABLE_CARD_SUPPORT
4117 int
4118 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
4119 {
4120   int rc;
4121   unsigned char *rsa_n = NULL;
4122   unsigned char *rsa_e = NULL;
4123   unsigned char *rsa_p = NULL;
4124   unsigned char *rsa_q = NULL;
4125   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
4126   unsigned char *sexp = NULL;
4127   unsigned char *p;
4128   char numbuf[55], numbuf2[50];
4129
4130   assert (is_RSA (sk->pubkey_algo));
4131   assert (!sk->is_protected);
4132
4133   /* Copy the parameters into straight buffers. */
4134   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_n, &rsa_n_len, sk->skey[0]);
4135   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_e, &rsa_e_len, sk->skey[1]);
4136   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_p, &rsa_p_len, sk->skey[3]);
4137   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_q, &rsa_q_len, sk->skey[4]);
4138   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
4139     {
4140       rc = G10ERR_INV_ARG;
4141       goto leave;
4142     }
4143
4144    /* Put the key into an S-expression. */
4145   sexp = p = xmalloc_secure (30
4146                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
4147                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
4148
4149   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
4150   sprintf (numbuf, "%u:", (unsigned int)rsa_n_len);
4151   p = stpcpy (p, numbuf);
4152   memcpy (p, rsa_n, rsa_n_len);
4153   p += rsa_n_len;
4154
4155   sprintf (numbuf, ")(1:e%u:", (unsigned int)rsa_e_len);
4156   p = stpcpy (p, numbuf);
4157   memcpy (p, rsa_e, rsa_e_len);
4158   p += rsa_e_len;
4159
4160   sprintf (numbuf, ")(1:p%u:", (unsigned int)rsa_p_len);
4161   p = stpcpy (p, numbuf);
4162   memcpy (p, rsa_p, rsa_p_len);
4163   p += rsa_p_len;
4164
4165   sprintf (numbuf, ")(1:q%u:", (unsigned int)rsa_q_len);
4166   p = stpcpy (p, numbuf);
4167   memcpy (p, rsa_q, rsa_q_len);
4168   p += rsa_q_len;
4169
4170   p = stpcpy (p,"))(10:created-at");
4171   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
4172   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
4173   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
4174
4175   /* Fixme: Unfortunately we don't have the serialnumber available -
4176      thus we can't pass it down to the agent. */ 
4177   rc = agent_scd_writekey (keyno, NULL, sexp, p - sexp);
4178
4179  leave:
4180   xfree (sexp);
4181   xfree (rsa_n);
4182   xfree (rsa_e);
4183   xfree (rsa_p);
4184   xfree (rsa_q);
4185   return rc;
4186 }
4187 #endif /*ENABLE_CARD_SUPPORT*/