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