Moved 1.9 branch to trunk
[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             /* FIXME: This check yields warning on alhas: Write a
1853                configure check and to this check here only for 32 bit
1854                machines */
1855             if( (time_t)((ulong)(curtime+interval)) < 0 )
1856               tty_printf(_("Your system can't display dates beyond 2038.\n"
1857                            "However, it will be correctly handled up to 2106.\n"));
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 we do not have dev/random
1953          * or it is switched into  quick testmode */
1954         /* FIXME: see skclist.c:random_is_faked */
1955         /*      if( quick_random_gen(-1)  ) */
1956         /*          strcpy(p, " (INSECURE!)" ); */
1957
1958         /* print a note in case that UTF8 mapping has to be done */
1959         for(p=uid; *p; p++ ) {
1960             if( *p & 0x80 ) {
1961                 tty_printf(_("You are using the `%s' character set.\n"),
1962                            get_native_charset() );
1963                 break;
1964             }
1965         }
1966
1967         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1968         /* fixme: add a warning if this user-id already exists */
1969         if( !*amail && !opt.allow_freeform_uid
1970             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1971             fail = 1;
1972             tty_printf(_("Please don't put the email address "
1973                           "into the real name or the comment\n") );
1974         }
1975
1976         for(;;) {
1977             /* TRANSLATORS: These are the allowed answers in
1978                lower and uppercase.  Below you will find the matching
1979                string which should be translated accordingly and the
1980                letter changed to match the one in the answer string.
1981                
1982                  n = Change name
1983                  c = Change comment
1984                  e = Change email
1985                  o = Okay (ready, continue)
1986                  q = Quit
1987              */
1988             const char *ansstr = _("NnCcEeOoQq");
1989
1990             if( strlen(ansstr) != 10 )
1991                 BUG();
1992             if( cpr_enabled() ) {
1993                 answer = xstrdup(ansstr+6);
1994                 answer[1] = 0;
1995             }
1996             else {
1997                 answer = cpr_get("keygen.userid.cmd", fail?
1998                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1999                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2000                 cpr_kill_prompt();
2001             }
2002             if( strlen(answer) > 1 )
2003                 ;
2004             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2005                 xfree(aname); aname = NULL;
2006                 break;
2007             }
2008             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2009                 xfree(acomment); acomment = NULL;
2010                 break;
2011             }
2012             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2013                 xfree(amail); amail = NULL;
2014                 break;
2015             }
2016             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2017                 if( fail ) {
2018                     tty_printf(_("Please correct the error first\n"));
2019                 }
2020                 else {
2021                     xfree(aname); aname = NULL;
2022                     xfree(acomment); acomment = NULL;
2023                     xfree(amail); amail = NULL;
2024                     break;
2025                 }
2026             }
2027             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2028                 xfree(aname); aname = NULL;
2029                 xfree(acomment); acomment = NULL;
2030                 xfree(amail); amail = NULL;
2031                 xfree(uid); uid = NULL;
2032                 break;
2033             }
2034             xfree(answer);
2035         }
2036         xfree(answer);
2037         if( !amail && !acomment && !amail )
2038             break;
2039         xfree(uid); uid = NULL;
2040     }
2041     if( uid ) {
2042         char *p = native_to_utf8( uid );
2043         xfree( uid );
2044         uid = p;
2045     }
2046     return uid;
2047 }
2048
2049
2050 /* FIXME: We need a way to cancel this prompt. */
2051 static DEK *
2052 do_ask_passphrase( STRING2KEY **ret_s2k )
2053 {
2054     DEK *dek = NULL;
2055     STRING2KEY *s2k;
2056     const char *errtext = NULL;
2057
2058     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2059
2060     s2k = xmalloc_secure( sizeof *s2k );
2061     for(;;) {
2062         s2k->mode = opt.s2k_mode;
2063         s2k->hash_algo = S2K_DIGEST_ALGO;
2064         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
2065                                  errtext, NULL);
2066         if( !dek ) {
2067             errtext = N_("passphrase not correctly repeated; try again");
2068             tty_printf(_("%s.\n"), _(errtext));
2069         }
2070         else if( !dek->keylen ) {
2071             xfree(dek); dek = NULL;
2072             xfree(s2k); s2k = NULL;
2073             tty_printf(_(
2074             "You don't want a passphrase - this is probably a *bad* idea!\n"
2075             "I will do it anyway.  You can change your passphrase at any time,\n"
2076             "using this program with the option \"--edit-key\".\n\n"));
2077             break;
2078         }
2079         else
2080             break; /* okay */
2081     }
2082     *ret_s2k = s2k;
2083     return dek;
2084 }
2085
2086
2087 static int
2088 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
2089            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
2090            int is_subkey )
2091 {
2092   int rc=0;
2093
2094   if( !opt.batch )
2095     tty_printf(_(
2096 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2097 "some other action (type on the keyboard, move the mouse, utilize the\n"
2098 "disks) during the prime generation; this gives the random number\n"
2099 "generator a better chance to gain enough entropy.\n") );
2100
2101   if( algo == PUBKEY_ALGO_ELGAMAL_E )
2102     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
2103                  is_subkey);
2104   else if( algo == PUBKEY_ALGO_DSA )
2105     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
2106                  is_subkey);
2107   else if( algo == PUBKEY_ALGO_RSA )
2108     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
2109                  is_subkey);
2110   else
2111     BUG();
2112
2113   return rc;
2114 }
2115
2116
2117 /****************
2118  * Generate a new user id packet, or return NULL if canceled
2119  */
2120 PKT_user_id *
2121 generate_user_id()
2122 {
2123     PKT_user_id *uid;
2124     char *p;
2125     size_t n;
2126
2127     p = ask_user_id( 1 );
2128     if( !p )
2129         return NULL;
2130     n = strlen(p);
2131     uid = xmalloc_clear( sizeof *uid + n - 1 );
2132     uid->len = n;
2133     strcpy(uid->name, p);
2134     uid->ref = 1;
2135     return uid;
2136 }
2137
2138
2139 static void
2140 release_parameter_list( struct para_data_s *r )
2141 {
2142     struct para_data_s *r2;
2143
2144     for( ; r ; r = r2 ) {
2145         r2 = r->next;
2146         if( r->key == pPASSPHRASE_DEK )
2147             xfree( r->u.dek );
2148         else if( r->key == pPASSPHRASE_S2K )
2149             xfree( r->u.s2k );
2150
2151         xfree(r);
2152     }
2153 }
2154
2155 static struct para_data_s *
2156 get_parameter( struct para_data_s *para, enum para_name key )
2157 {
2158     struct para_data_s *r;
2159
2160     for( r = para; r && r->key != key; r = r->next )
2161         ;
2162     return r;
2163 }
2164
2165 static const char *
2166 get_parameter_value( struct para_data_s *para, enum para_name key )
2167 {
2168     struct para_data_s *r = get_parameter( para, key );
2169     return (r && *r->u.value)? r->u.value : NULL;
2170 }
2171
2172 static int
2173 get_parameter_algo( struct para_data_s *para, enum para_name key )
2174 {
2175     int i;
2176     struct para_data_s *r = get_parameter( para, key );
2177     if( !r )
2178         return -1;
2179     if( digitp( r->u.value ) )
2180         i = atoi( r->u.value );
2181     else
2182         i = gcry_pk_map_name (r->u.value);
2183     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2184       i = 0; /* we don't want to allow generation of these algorithms */
2185     return i;
2186 }
2187
2188 /* 
2189  * parse the usage parameter and set the keyflags.  Return true on error.
2190  */
2191 static int
2192 parse_parameter_usage (const char *fname,
2193                        struct para_data_s *para, enum para_name key)
2194 {
2195     struct para_data_s *r = get_parameter( para, key );
2196     char *p, *pn;
2197     unsigned int use;
2198
2199     if( !r )
2200         return 0; /* none (this is an optional parameter)*/
2201     
2202     use = 0;
2203     pn = r->u.value;
2204     while ( (p = strsep (&pn, " \t,")) ) {
2205         if ( !*p)
2206             ;
2207         else if ( !ascii_strcasecmp (p, "sign") )
2208             use |= PUBKEY_USAGE_SIG;
2209         else if ( !ascii_strcasecmp (p, "encrypt") )
2210             use |= PUBKEY_USAGE_ENC;
2211         else if ( !ascii_strcasecmp (p, "auth") )
2212             use |= PUBKEY_USAGE_AUTH;
2213         else {
2214             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2215             return -1; /* error */
2216         }
2217     }
2218     r->u.usage = use;
2219     return 1;
2220 }
2221
2222 static int
2223 parse_revocation_key (const char *fname,
2224                       struct para_data_s *para, enum para_name key)
2225 {
2226   struct para_data_s *r = get_parameter( para, key );
2227   struct revocation_key revkey;
2228   char *pn;
2229   int i;
2230
2231   if( !r )
2232     return 0; /* none (this is an optional parameter) */
2233
2234   pn = r->u.value;
2235
2236   revkey.class=0x80;
2237   revkey.algid=atoi(pn);
2238   if(!revkey.algid)
2239     goto fail;
2240
2241   /* Skip to the fpr */
2242   while(*pn && *pn!=':')
2243     pn++;
2244
2245   if(*pn!=':')
2246     goto fail;
2247
2248   pn++;
2249
2250   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2251     {
2252       int c=hextobyte(pn);
2253       if(c==-1)
2254         goto fail;
2255
2256       revkey.fpr[i]=c;
2257     }
2258
2259   /* skip to the tag */
2260   while(*pn && *pn!='s' && *pn!='S')
2261     pn++;
2262
2263   if(ascii_strcasecmp(pn,"sensitive")==0)
2264     revkey.class|=0x40;
2265
2266   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2267
2268   return 0;
2269
2270   fail:
2271   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2272   return -1; /* error */
2273 }
2274
2275
2276 static u32
2277 get_parameter_u32( struct para_data_s *para, enum para_name key )
2278 {
2279     struct para_data_s *r = get_parameter( para, key );
2280
2281     if( !r )
2282         return 0;
2283     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2284         return r->u.expire;
2285     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2286         return r->u.usage;
2287
2288     return (unsigned int)strtoul( r->u.value, NULL, 10 );
2289 }
2290
2291 static unsigned int
2292 get_parameter_uint( struct para_data_s *para, enum para_name key )
2293 {
2294     return get_parameter_u32( para, key );
2295 }
2296
2297 static DEK *
2298 get_parameter_dek( struct para_data_s *para, enum para_name key )
2299 {
2300     struct para_data_s *r = get_parameter( para, key );
2301     return r? r->u.dek : NULL;
2302 }
2303
2304 static STRING2KEY *
2305 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2306 {
2307     struct para_data_s *r = get_parameter( para, key );
2308     return r? r->u.s2k : NULL;
2309 }
2310
2311 static struct revocation_key *
2312 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2313 {
2314     struct para_data_s *r = get_parameter( para, key );
2315     return r? &r->u.revkey : NULL;
2316 }
2317
2318 static int
2319 proc_parameter_file( struct para_data_s *para, const char *fname,
2320                      struct output_control_s *outctrl, int card )
2321 {
2322   struct para_data_s *r;
2323   const char *s1, *s2, *s3;
2324   size_t n;
2325   char *p;
2326   int have_user_id=0,err,algo;
2327
2328   /* Check that we have all required parameters. */
2329   r = get_parameter( para, pKEYTYPE );
2330   if(r)
2331     {
2332       algo=get_parameter_algo(para,pKEYTYPE);
2333       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2334         {
2335           log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2336           return -1;
2337         }
2338     }
2339   else
2340     {
2341       log_error("%s: no Key-Type specified\n",fname);
2342       return -1;
2343     }
2344
2345   err=parse_parameter_usage (fname, para, pKEYUSAGE);
2346   if(err==0)
2347     {
2348       /* Default to algo capabilities if key-usage is not provided */
2349       r=xmalloc_clear(sizeof(*r));
2350       r->key=pKEYUSAGE;
2351       r->u.usage=openpgp_pk_algo_usage(algo);
2352       r->next=para;
2353       para=r;
2354     }
2355   else if(err==-1)
2356     return -1;
2357
2358   r = get_parameter( para, pSUBKEYTYPE );
2359   if(r)
2360     {
2361       algo=get_parameter_algo( para, pSUBKEYTYPE);
2362       if (openpgp_pk_test_algo (algo))
2363         {
2364           log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2365           return -1;
2366         }
2367
2368       err=parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2369       if(err==0)
2370         {
2371           /* Default to algo capabilities if subkey-usage is not
2372              provided */
2373           r=xmalloc_clear(sizeof(*r));
2374           r->key=pSUBKEYUSAGE;
2375           r->u.usage=openpgp_pk_algo_usage(algo);
2376           r->next=para;
2377           para=r;
2378         }
2379       else if(err==-1)
2380         return -1;
2381     }
2382
2383   if( get_parameter_value( para, pUSERID ) )
2384     have_user_id=1;
2385   else
2386     {
2387       /* create the formatted user ID */
2388       s1 = get_parameter_value( para, pNAMEREAL );
2389       s2 = get_parameter_value( para, pNAMECOMMENT );
2390       s3 = get_parameter_value( para, pNAMEEMAIL );
2391       if( s1 || s2 || s3 )
2392         {
2393           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2394           r = xmalloc_clear( sizeof *r + n + 20 );
2395           r->key = pUSERID;
2396           p = r->u.value;
2397           if( s1 )
2398             p = stpcpy(p, s1 );
2399           if( s2 )
2400             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2401           if( s3 )
2402             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2403           r->next = para;
2404           para = r;
2405           have_user_id=1;
2406         }
2407     }
2408
2409   if(!have_user_id)
2410     {
2411       log_error("%s: no User-ID specified\n",fname);
2412       return -1;
2413     }
2414
2415   /* Set preferences, if any. */
2416   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2417
2418   /* Set keyserver, if any. */
2419   s1=get_parameter_value( para, pKEYSERVER );
2420   if(s1)
2421     {
2422       struct keyserver_spec *spec;
2423
2424       spec=parse_keyserver_uri(s1,1,NULL,0);
2425       if(spec)
2426         {
2427           free_keyserver_spec(spec);
2428           opt.def_keyserver_url=s1;
2429         }
2430       else
2431         {
2432           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2433           return -1;
2434         }
2435     }
2436
2437   /* Set revoker, if any. */
2438   if (parse_revocation_key (fname, para, pREVOKER))
2439     return -1;
2440
2441   /* make DEK and S2K from the Passphrase */
2442   r = get_parameter( para, pPASSPHRASE );
2443   if( r && *r->u.value ) {
2444     /* we have a plain text passphrase - create a DEK from it.
2445      * It is a little bit ridiculous to keep it ih secure memory
2446      * but becuase we do this alwasy, why not here */
2447     STRING2KEY *s2k;
2448     DEK *dek;
2449
2450     s2k = xmalloc_secure( sizeof *s2k );
2451     s2k->mode = opt.s2k_mode;
2452     s2k->hash_algo = S2K_DIGEST_ALGO;
2453     set_next_passphrase( r->u.value );
2454     dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2455                              NULL, NULL);
2456     set_next_passphrase( NULL );
2457     assert( dek );
2458     memset( r->u.value, 0, strlen(r->u.value) );
2459
2460     r = xmalloc_clear( sizeof *r );
2461     r->key = pPASSPHRASE_S2K;
2462     r->u.s2k = s2k;
2463     r->next = para;
2464     para = r;
2465     r = xmalloc_clear( sizeof *r );
2466     r->key = pPASSPHRASE_DEK;
2467     r->u.dek = dek;
2468     r->next = para;
2469     para = r;
2470   }
2471
2472   /* make KEYEXPIRE from Expire-Date */
2473   r = get_parameter( para, pEXPIREDATE );
2474   if( r && *r->u.value )
2475     {
2476       u32 seconds;
2477
2478       seconds = parse_expire_string( r->u.value );
2479       if( seconds == (u32)-1 )
2480         {
2481           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2482           return -1;
2483         }
2484       r->u.expire = seconds;
2485       r->key = pKEYEXPIRE;  /* change hat entry */
2486       /* also set it for the subkey */
2487       r = xmalloc_clear( sizeof *r + 20 );
2488       r->key = pSUBKEYEXPIRE;
2489       r->u.expire = seconds;
2490       r->next = para;
2491       para = r;
2492     }
2493
2494   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2495     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2496     return -1;
2497   }
2498
2499   do_generate_keypair( para, outctrl, card );
2500   return 0;
2501 }
2502
2503
2504 /****************
2505  * Kludge to allow non interactive key generation controlled
2506  * by a parameter file.
2507  * Note, that string parameters are expected to be in UTF-8
2508  */
2509 static void
2510 read_parameter_file( const char *fname )
2511 {
2512     static struct { const char *name;
2513                     enum para_name key;
2514     } keywords[] = {
2515         { "Key-Type",       pKEYTYPE},
2516         { "Key-Length",     pKEYLENGTH },
2517         { "Key-Usage",      pKEYUSAGE },
2518         { "Subkey-Type",    pSUBKEYTYPE },
2519         { "Subkey-Length",  pSUBKEYLENGTH },
2520         { "Subkey-Usage",   pSUBKEYUSAGE },
2521         { "Name-Real",      pNAMEREAL },
2522         { "Name-Email",     pNAMEEMAIL },
2523         { "Name-Comment",   pNAMECOMMENT },
2524         { "Expire-Date",    pEXPIREDATE },
2525         { "Passphrase",     pPASSPHRASE },
2526         { "Preferences",    pPREFERENCES },
2527         { "Revoker",        pREVOKER },
2528         { "Handle",         pHANDLE },
2529         { "Keyserver",      pKEYSERVER },
2530         { NULL, 0 }
2531     };
2532     IOBUF fp;
2533     byte *line;
2534     unsigned int maxlen, nline;
2535     char *p;
2536     int lnr;
2537     const char *err = NULL;
2538     struct para_data_s *para, *r;
2539     int i;
2540     struct output_control_s outctrl;
2541
2542     memset( &outctrl, 0, sizeof( outctrl ) );
2543
2544     if( !fname || !*fname)
2545       fname = "-";
2546
2547     fp = iobuf_open (fname);
2548     if (fp && is_secured_file (iobuf_get_fd (fp)))
2549       {
2550         iobuf_close (fp);
2551         fp = NULL;
2552         errno = EPERM;
2553       }
2554     if (!fp) {
2555       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2556       return;
2557     }
2558     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2559
2560     lnr = 0;
2561     err = NULL;
2562     para = NULL;
2563     maxlen = 1024;
2564     line = NULL;
2565     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2566         char *keyword, *value;
2567
2568         lnr++;
2569         if( !maxlen ) {
2570             err = "line too long";
2571             break;
2572         }
2573         for( p = line; isspace(*(byte*)p); p++ )
2574             ;
2575         if( !*p || *p == '#' )
2576             continue;
2577         keyword = p;
2578         if( *keyword == '%' ) {
2579             for( ; !isspace(*(byte*)p); p++ )
2580                 ;
2581             if( *p )
2582                 *p++ = 0;
2583             for( ; isspace(*(byte*)p); p++ )
2584                 ;
2585             value = p;
2586             trim_trailing_ws( value, strlen(value) );
2587             if( !ascii_strcasecmp( keyword, "%echo" ) )
2588                 log_info("%s\n", value );
2589             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2590                 outctrl.dryrun = 1;
2591             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2592                 outctrl.lnr = lnr;
2593                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2594                   print_status_key_not_created 
2595                     (get_parameter_value (para, pHANDLE));
2596                 release_parameter_list( para );
2597                 para = NULL;
2598             }
2599             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2600                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2601                     ; /* still the same file - ignore it */
2602                 else {
2603                     xfree( outctrl.pub.newfname );
2604                     outctrl.pub.newfname = xstrdup( value );
2605                     outctrl.use_files = 1;
2606                 }
2607             }
2608             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2609                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2610                     ; /* still the same file - ignore it */
2611                 else {
2612                    xfree( outctrl.sec.newfname );
2613                    outctrl.sec.newfname = xstrdup( value );
2614                    outctrl.use_files = 1;
2615                 }
2616             }
2617             else
2618                 log_info("skipping control `%s' (%s)\n", keyword, value );
2619
2620
2621             continue;
2622         }
2623
2624
2625         if( !(p = strchr( p, ':' )) || p == keyword ) {
2626             err = "missing colon";
2627             break;
2628         }
2629         if( *p )
2630             *p++ = 0;
2631         for( ; isspace(*(byte*)p); p++ )
2632             ;
2633         if( !*p ) {
2634             err = "missing argument";
2635             break;
2636         }
2637         value = p;
2638         trim_trailing_ws( value, strlen(value) );
2639
2640         for(i=0; keywords[i].name; i++ ) {
2641             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2642                 break;
2643         }
2644         if( !keywords[i].name ) {
2645             err = "unknown keyword";
2646             break;
2647         }
2648         if( keywords[i].key != pKEYTYPE && !para ) {
2649             err = "parameter block does not start with \"Key-Type\"";
2650             break;
2651         }
2652
2653         if( keywords[i].key == pKEYTYPE && para ) {
2654             outctrl.lnr = lnr;
2655             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2656               print_status_key_not_created
2657                 (get_parameter_value (para, pHANDLE));
2658             release_parameter_list( para );
2659             para = NULL;
2660         }
2661         else {
2662             for( r = para; r; r = r->next ) {
2663                 if( r->key == keywords[i].key )
2664                     break;
2665             }
2666             if( r ) {
2667                 err = "duplicate keyword";
2668                 break;
2669             }
2670         }
2671         r = xmalloc_clear( sizeof *r + strlen( value ) );
2672         r->lnr = lnr;
2673         r->key = keywords[i].key;
2674         strcpy( r->u.value, value );
2675         r->next = para;
2676         para = r;
2677     }
2678     if( err )
2679         log_error("%s:%d: %s\n", fname, lnr, err );
2680     else if( iobuf_error (fp) ) {
2681         log_error("%s:%d: read error\n", fname, lnr);
2682     }
2683     else if( para ) {
2684         outctrl.lnr = lnr;
2685         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2686           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2687     }
2688
2689     if( outctrl.use_files ) { /* close open streams */
2690         iobuf_close( outctrl.pub.stream );
2691         iobuf_close( outctrl.sec.stream );
2692
2693         /* Must invalidate that ugly cache to actually close it.  */
2694         if (outctrl.pub.fname)
2695           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2696         if (outctrl.sec.fname)
2697           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2698
2699         xfree( outctrl.pub.fname );
2700         xfree( outctrl.pub.newfname );
2701         xfree( outctrl.sec.fname );
2702         xfree( outctrl.sec.newfname );
2703     }
2704
2705     release_parameter_list( para );
2706     iobuf_close (fp);
2707 }
2708
2709
2710 /*
2711  * Generate a keypair (fname is only used in batch mode) If
2712  * CARD_SERIALNO is not NULL the function will create the keys on an
2713  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2714  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2715  * generate in software, imported to the card and a backup file
2716  * written to directory given by this argument .
2717  */
2718 void
2719 generate_keypair (const char *fname, const char *card_serialno, 
2720                   const char *backup_encryption_dir)
2721 {
2722   unsigned int nbits;
2723   char *uid = NULL;
2724   DEK *dek;
2725   STRING2KEY *s2k;
2726   int algo;
2727   unsigned int use;
2728   int both = 0;
2729   u32 expire;
2730   struct para_data_s *para = NULL;
2731   struct para_data_s *r;
2732   struct output_control_s outctrl;
2733   
2734   memset( &outctrl, 0, sizeof( outctrl ) );
2735   
2736   if (opt.batch && card_serialno)
2737     {
2738       /* We don't yet support unattended key generation. */
2739       log_error (_("can't do this in batch mode\n"));
2740       return;
2741     }
2742   
2743   if (opt.batch)
2744     {
2745       read_parameter_file( fname );
2746       return;
2747     }
2748
2749   if (card_serialno)
2750     {
2751 #ifdef ENABLE_CARD_SUPPORT
2752       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2753       r->key = pSERIALNO;
2754       strcpy( r->u.value, card_serialno);
2755       r->next = para;
2756       para = r;
2757        
2758       algo = PUBKEY_ALGO_RSA;
2759        
2760       r = xcalloc (1, sizeof *r + 20 );
2761       r->key = pKEYTYPE;
2762       sprintf( r->u.value, "%d", algo );
2763       r->next = para;
2764       para = r;
2765       r = xcalloc (1, sizeof *r + 20 );
2766       r->key = pKEYUSAGE;
2767       strcpy (r->u.value, "sign");
2768       r->next = para;
2769       para = r;
2770        
2771       r = xcalloc (1, sizeof *r + 20 );
2772       r->key = pSUBKEYTYPE;
2773       sprintf( r->u.value, "%d", algo );
2774       r->next = para;
2775       para = r;
2776       r = xcalloc (1, sizeof *r + 20 );
2777       r->key = pSUBKEYUSAGE;
2778       strcpy (r->u.value, "encrypt");
2779       r->next = para;
2780       para = r;
2781        
2782       r = xcalloc (1, sizeof *r + 20 );
2783       r->key = pAUTHKEYTYPE;
2784       sprintf( r->u.value, "%d", algo );
2785       r->next = para;
2786       para = r;
2787
2788       if (backup_encryption_dir)
2789         {
2790           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2791           r->key = pBACKUPENCDIR;
2792           strcpy (r->u.value, backup_encryption_dir);
2793           r->next = para;
2794           para = r;
2795         }
2796 #endif /*ENABLE_CARD_SUPPORT*/
2797     }
2798   else
2799     {
2800       algo = ask_algo( 0, &use );
2801       if( !algo )
2802         { /* default: DSA with ElG subkey of the specified size */
2803           both = 1;
2804           r = xmalloc_clear( sizeof *r + 20 );
2805           r->key = pKEYTYPE;
2806           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2807           r->next = para;
2808           para = r;
2809           nbits = ask_keysize( PUBKEY_ALGO_DSA );
2810           r = xmalloc_clear( sizeof *r + 20 );
2811           r->key = pKEYLENGTH;
2812           sprintf( r->u.value, "%u", nbits);
2813           r->next = para;
2814           para = r;
2815           r = xmalloc_clear( sizeof *r + 20 );
2816           r->key = pKEYUSAGE;
2817           strcpy( r->u.value, "sign" );
2818           r->next = para;
2819           para = r;
2820            
2821           algo = PUBKEY_ALGO_ELGAMAL_E;
2822           r = xmalloc_clear( sizeof *r + 20 );
2823           r->key = pSUBKEYTYPE;
2824           sprintf( r->u.value, "%d", algo );
2825           r->next = para;
2826           para = r;
2827           r = xmalloc_clear( sizeof *r + 20 );
2828           r->key = pSUBKEYUSAGE;
2829           strcpy( r->u.value, "encrypt" );
2830           r->next = para;
2831           para = r;
2832         }
2833       else 
2834         {
2835           r = xmalloc_clear( sizeof *r + 20 );
2836           r->key = pKEYTYPE;
2837           sprintf( r->u.value, "%d", algo );
2838           r->next = para;
2839           para = r;
2840            
2841           if (use)
2842             {
2843               r = xmalloc_clear( sizeof *r + 25 );
2844               r->key = pKEYUSAGE;
2845               sprintf( r->u.value, "%s%s%s",
2846                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2847                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
2848                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
2849               r->next = para;
2850               para = r;
2851             }
2852            
2853         }
2854
2855       nbits = ask_keysize( algo );
2856       r = xmalloc_clear( sizeof *r + 20 );
2857       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2858       sprintf( r->u.value, "%u", nbits);
2859       r->next = para;
2860       para = r;
2861     }
2862    
2863   expire = ask_expire_interval(0,NULL);
2864   r = xmalloc_clear( sizeof *r + 20 );
2865   r->key = pKEYEXPIRE;
2866   r->u.expire = expire;
2867   r->next = para;
2868   para = r;
2869   r = xmalloc_clear( sizeof *r + 20 );
2870   r->key = pSUBKEYEXPIRE;
2871   r->u.expire = expire;
2872   r->next = para;
2873   para = r;
2874
2875   uid = ask_user_id(0);
2876   if( !uid ) 
2877     {
2878       log_error(_("Key generation canceled.\n"));
2879       release_parameter_list( para );
2880       return;
2881     }
2882   r = xmalloc_clear( sizeof *r + strlen(uid) );
2883   r->key = pUSERID;
2884   strcpy( r->u.value, uid );
2885   r->next = para;
2886   para = r;
2887     
2888   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2889   if( dek )
2890     {
2891       r = xmalloc_clear( sizeof *r );
2892       r->key = pPASSPHRASE_DEK;
2893       r->u.dek = dek;
2894       r->next = para;
2895       para = r;
2896       r = xmalloc_clear( sizeof *r );
2897       r->key = pPASSPHRASE_S2K;
2898       r->u.s2k = s2k;
2899       r->next = para;
2900       para = r;
2901     }
2902     
2903   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2904   release_parameter_list( para );
2905 }
2906
2907
2908 #ifdef ENABLE_CARD_SUPPORT
2909 /* Generate a raw key and return it as a secret key packet.  The
2910    function will ask for the passphrase and return a protected as well
2911    as an unprotected copy of a new secret key packet.  0 is returned
2912    on success and the caller must then free the returned values.  */
2913 static int
2914 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
2915                   PKT_secret_key **r_sk_unprotected,
2916                   PKT_secret_key **r_sk_protected)
2917 {
2918   int rc;
2919   DEK *dek = NULL;
2920   STRING2KEY *s2k = NULL;
2921   PKT_secret_key *sk = NULL;
2922   int i;
2923   size_t nskey, npkey;
2924
2925   npkey = pubkey_get_npkey (algo);
2926   nskey = pubkey_get_nskey (algo);
2927   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
2928
2929   if (nbits < 512)
2930     {
2931       nbits = 512;
2932       log_info (_("keysize invalid; using %u bits\n"), nbits );
2933     }
2934
2935   if ((nbits % 32)) 
2936     {
2937       nbits = ((nbits + 31) / 32) * 32;
2938       log_info(_("keysize rounded up to %u bits\n"), nbits );
2939     }
2940
2941   dek = do_ask_passphrase (&s2k);
2942
2943   sk = xmalloc_clear (sizeof *sk);
2944   sk->timestamp = created_at;
2945   sk->version = 4;
2946   sk->pubkey_algo = algo;
2947
2948   if ( !is_RSA (algo) )
2949     {
2950       log_error ("only RSA is supported for offline generated keys\n");
2951       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2952       goto leave;
2953     }
2954   rc = gcry_sexp_build (&s_parms, NULL,
2955                         "(genkey(rsa(nbits %d)))",
2956                         (int)nbits);
2957   if (rc)
2958     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
2959   rc = gcry_pk_genkey (&s_key, s_parms);
2960   gcry_sexp_release (s_parms);
2961   if (rc)
2962     {
2963       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
2964       goto leave;
2965     }
2966   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
2967   gcry_sexp_release (s_key);
2968   if (rc) 
2969     {
2970       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
2971       goto leave;
2972     }
2973   
2974   for (i=npkey; i < nskey; i++)
2975     sk->csum += checksum_mpi (sk->skey[i]);
2976
2977   if (r_sk_unprotected) 
2978     *r_sk_unprotected = copy_secret_key (NULL, sk);
2979
2980   rc = genhelp_protect (dek, s2k, sk);
2981   if (rc)
2982     goto leave;
2983
2984   if (r_sk_protected)
2985     {
2986       *r_sk_protected = sk;
2987       sk = NULL;
2988     }
2989
2990  leave:
2991   if (sk)
2992     free_secret_key (sk);
2993   xfree (dek);
2994   xfree (s2k);
2995   return rc;
2996 }
2997 #endif /* ENABLE_CARD_SUPPORT */
2998
2999 /* Create and delete a dummy packet to start off a list of kbnodes. */
3000 static void
3001 start_tree(KBNODE *tree)
3002 {
3003   PACKET *pkt;
3004
3005   pkt=xmalloc_clear(sizeof(*pkt));
3006   pkt->pkttype=PKT_NONE;
3007   *tree=new_kbnode(pkt);
3008   delete_kbnode(*tree);
3009 }
3010
3011 static void
3012 do_generate_keypair( struct para_data_s *para,
3013                      struct output_control_s *outctrl, int card )
3014 {
3015     KBNODE pub_root = NULL;
3016     KBNODE sec_root = NULL;
3017     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3018     const char *s;
3019     struct revocation_key *revkey;
3020     int rc;
3021     int did_sub = 0;
3022
3023     if( outctrl->dryrun )
3024       {
3025         log_info("dry-run mode - key generation skipped\n");
3026         return;
3027       }
3028
3029     if( outctrl->use_files ) {
3030         if( outctrl->pub.newfname ) {
3031             iobuf_close(outctrl->pub.stream);
3032             outctrl->pub.stream = NULL;
3033             if (outctrl->pub.fname)
3034               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
3035             xfree( outctrl->pub.fname );
3036             outctrl->pub.fname =  outctrl->pub.newfname;
3037             outctrl->pub.newfname = NULL;
3038
3039             if (is_secured_filename (outctrl->pub.fname) ) {
3040                 outctrl->pub.stream = NULL;
3041                 errno = EPERM;
3042             }
3043             else
3044                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3045             if( !outctrl->pub.stream ) {
3046                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3047                                                      strerror(errno) );
3048                 return;
3049             }
3050             if( opt.armor ) {
3051                 outctrl->pub.afx.what = 1;
3052                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
3053                                                     &outctrl->pub.afx );
3054             }
3055         }
3056         if( outctrl->sec.newfname ) {
3057             mode_t oldmask;
3058
3059             iobuf_close(outctrl->sec.stream);
3060             outctrl->sec.stream = NULL;
3061             if (outctrl->sec.fname)
3062               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3063             xfree( outctrl->sec.fname );
3064             outctrl->sec.fname =  outctrl->sec.newfname;
3065             outctrl->sec.newfname = NULL;
3066
3067             oldmask = umask (077);
3068             if (is_secured_filename (outctrl->sec.fname) ) {
3069                 outctrl->sec.stream = NULL;
3070                 errno = EPERM;
3071             }
3072             else
3073                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3074             umask (oldmask);
3075             if( !outctrl->sec.stream ) {
3076                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3077                                                      strerror(errno) );
3078                 return;
3079             }
3080             if( opt.armor ) {
3081                 outctrl->sec.afx.what = 5;
3082                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
3083                                                     &outctrl->sec.afx );
3084             }
3085         }
3086         assert( outctrl->pub.stream );
3087         assert( outctrl->sec.stream );
3088         if( opt.verbose ) {
3089             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
3090             if (card)
3091               log_info (_("writing secret key stub to `%s'\n"),
3092                         outctrl->sec.fname);
3093             else
3094               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3095         }
3096     }
3097
3098
3099     /* we create the packets as a tree of kbnodes. Because the
3100      * structure we create is known in advance we simply generate a
3101      * linked list.  The first packet is a dummy packet which we flag
3102      * as deleted.  The very first packet must always be a KEY packet.
3103      */
3104     
3105     start_tree(&pub_root);
3106     start_tree(&sec_root);
3107
3108     if (!card)
3109       {
3110         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
3111                         get_parameter_uint( para, pKEYLENGTH ),
3112                         pub_root, sec_root,
3113                         get_parameter_dek( para, pPASSPHRASE_DEK ),
3114                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
3115                         &pri_sk,
3116                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
3117       }
3118     else
3119       {
3120         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root, NULL,
3121                            get_parameter_u32 (para, pKEYEXPIRE), para);
3122         if (!rc)
3123           {
3124             pri_sk = sec_root->next->pkt->pkt.secret_key;
3125             assert (pri_sk);
3126           }
3127       }
3128
3129     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3130       {
3131         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
3132         if(!rc)
3133           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
3134       }
3135
3136     if( !rc && (s=get_parameter_value(para, pUSERID)) )
3137       {
3138         write_uid(pub_root, s );
3139         if( !rc )
3140           write_uid(sec_root, s );
3141
3142         if( !rc )
3143           rc = write_selfsigs(sec_root, pub_root, pri_sk,
3144                               get_parameter_uint (para, pKEYUSAGE));
3145       }
3146
3147     /* Write the auth key to the card before the encryption key.  This
3148        is a partial workaround for a PGP bug (as of this writing, all
3149        versions including 8.1), that causes it to try and encrypt to
3150        the most recent subkey regardless of whether that subkey is
3151        actually an encryption type.  In this case, the auth key is an
3152        RSA key so it succeeds. */
3153
3154     if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3155       {
3156         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root, NULL,
3157                            get_parameter_u32 (para, pKEYEXPIRE), para);
3158         
3159         if (!rc)
3160           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
3161         if (!rc)
3162           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
3163       }
3164
3165     if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3166       {
3167         if (!card)
3168           {
3169             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
3170                             get_parameter_uint( para, pSUBKEYLENGTH ),
3171                             pub_root, sec_root,
3172                             get_parameter_dek( para, pPASSPHRASE_DEK ),
3173                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
3174                             &sub_sk,
3175                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3176           }
3177         else
3178           {
3179             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3180               {
3181                 /* A backup of the encryption key has been requested.
3182                    Generate the key i software and import it then to
3183                    the card.  Write a backup file. */
3184                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3185                                                pub_root, sec_root,
3186                                                get_parameter_u32 (para,
3187                                                                   pKEYEXPIRE),
3188                                                para, s);
3189               }
3190             else
3191               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3192                                  NULL,
3193                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3194           }
3195
3196         if( !rc )
3197           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
3198                                 get_parameter_uint (para, pSUBKEYUSAGE));
3199         if( !rc )
3200           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
3201                                 get_parameter_uint (para, pSUBKEYUSAGE));
3202         did_sub = 1;
3203       }
3204
3205     if( !rc && outctrl->use_files ) { /* direct write to specified files */
3206         rc = write_keyblock( outctrl->pub.stream, pub_root );
3207         if( rc )
3208             log_error("can't write public key: %s\n", g10_errstr(rc) );
3209         if( !rc ) {
3210             rc = write_keyblock( outctrl->sec.stream, sec_root );
3211             if( rc )
3212                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
3213         }
3214
3215     }
3216     else if( !rc ) { /* write to the standard keyrings */
3217         KEYDB_HANDLE pub_hd = keydb_new (0);
3218         KEYDB_HANDLE sec_hd = keydb_new (1);
3219
3220         /* FIXME: we may have to create the keyring first */
3221         rc = keydb_locate_writable (pub_hd, NULL);
3222         if (rc) 
3223             log_error (_("no writable public keyring found: %s\n"),
3224                        g10_errstr (rc));
3225
3226         if (!rc) {  
3227             rc = keydb_locate_writable (sec_hd, NULL);
3228             if (rc) 
3229                 log_error (_("no writable secret keyring found: %s\n"),
3230                            g10_errstr (rc));
3231         }
3232
3233         if (!rc && opt.verbose) {
3234             log_info(_("writing public key to `%s'\n"),
3235                      keydb_get_resource_name (pub_hd));
3236             if (card)
3237               log_info (_("writing secret key stub to `%s'\n"),
3238                         keydb_get_resource_name (sec_hd));
3239             else
3240               log_info(_("writing secret key to `%s'\n"),
3241                        keydb_get_resource_name (sec_hd));
3242         }
3243
3244         if (!rc) {
3245             rc = keydb_insert_keyblock (pub_hd, pub_root);
3246             if (rc)
3247                 log_error (_("error writing public keyring `%s': %s\n"),
3248                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
3249         }
3250
3251         if (!rc) {
3252             rc = keydb_insert_keyblock (sec_hd, sec_root);
3253             if (rc)
3254                 log_error (_("error writing secret keyring `%s': %s\n"),
3255                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
3256         }
3257
3258         keydb_release (pub_hd);
3259         keydb_release (sec_hd);
3260
3261         if (!rc) {
3262             int no_enc_rsa =
3263                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
3264                 && get_parameter_uint( para, pKEYUSAGE )
3265                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
3266             PKT_public_key *pk = find_kbnode (pub_root, 
3267                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3268
3269             keyid_from_pk(pk,pk->main_keyid);
3270             register_trusted_keyid(pk->main_keyid);
3271
3272             update_ownertrust (pk,
3273                                ((get_ownertrust (pk) & ~TRUST_MASK)
3274                                 | TRUST_ULTIMATE ));
3275
3276             if (!opt.batch) {
3277                 tty_printf(_("public and secret key created and signed.\n") );
3278                 tty_printf("\n");
3279                 list_keyblock(pub_root,0,1,NULL);
3280             }
3281             
3282
3283             if( !opt.batch
3284                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
3285                      || no_enc_rsa )
3286                 && !get_parameter( para, pSUBKEYTYPE ) )
3287             {
3288                 tty_printf(_("Note that this key cannot be used for "
3289                              "encryption.  You may want to use\n"
3290                              "the command \"--edit-key\" to generate a "
3291                              "subkey for this purpose.\n") );
3292             }
3293         }
3294     }
3295
3296     if( rc ) {
3297         if( opt.batch )
3298             log_error("key generation failed: %s\n", g10_errstr(rc) );
3299         else
3300             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
3301         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3302     }
3303     else {
3304         PKT_public_key *pk = find_kbnode (pub_root, 
3305                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3306         print_status_key_created (did_sub? 'B':'P', pk,
3307                                   get_parameter_value (para, pHANDLE));
3308     }
3309     release_kbnode( pub_root );
3310     release_kbnode( sec_root );
3311
3312     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
3313       free_secret_key(pri_sk); /* shallow copy in card mode. */
3314     if( sub_sk )
3315         free_secret_key(sub_sk);
3316 }
3317
3318
3319 /****************
3320  * add a new subkey to an existing key.
3321  * Returns true if a new key has been generated and put into the keyblocks.
3322  */
3323 int
3324 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
3325 {
3326     int okay=0, rc=0;
3327     KBNODE node;
3328     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3329     int algo;
3330     unsigned int use;
3331     u32 expire;
3332     unsigned nbits;
3333     char *passphrase = NULL;
3334     DEK *dek = NULL;
3335     STRING2KEY *s2k = NULL;
3336     u32 cur_time;
3337     int ask_pass = 0;
3338
3339     /* break out the primary secret key */
3340     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3341     if( !node ) {
3342         log_error("Oops; secret key not found anymore!\n");
3343         goto leave;
3344     }
3345
3346     /* make a copy of the sk to keep the protected one in the keyblock */
3347     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
3348
3349     cur_time = make_timestamp();
3350     if( pri_sk->timestamp > cur_time ) {
3351         ulong d = pri_sk->timestamp - cur_time;
3352         log_info( d==1 ? _("key has been created %lu second "
3353                            "in future (time warp or clock problem)\n")
3354                        : _("key has been created %lu seconds "
3355                            "in future (time warp or clock problem)\n"), d );
3356         if( !opt.ignore_time_conflict ) {
3357             rc = G10ERR_TIME_CONFLICT;
3358             goto leave;
3359         }
3360     }
3361
3362     if (pri_sk->version < 4) {
3363         log_info (_("NOTE: creating subkeys for v3 keys "
3364                     "is not OpenPGP compliant\n"));
3365         goto leave;
3366     }
3367
3368     if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) {
3369         tty_printf(_("Secret parts of primary key are not available.\n"));
3370         rc = G10ERR_NO_SECKEY;
3371         goto leave;
3372     }
3373
3374
3375     /* Unprotect to get the passphrase.  */
3376     switch( is_secret_key_protected( pri_sk ) ) {
3377       case -1:
3378         rc = G10ERR_PUBKEY_ALGO;
3379         break;
3380       case 0:
3381         tty_printf(_("This key is not protected.\n"));
3382         break;
3383       case -2:
3384         tty_printf(_("Secret parts of primary key are stored on-card.\n"));
3385         ask_pass = 1;
3386         break;
3387       default:
3388         tty_printf(_("Key is protected.\n"));
3389         rc = check_secret_key( pri_sk, 0 );
3390         if( !rc )
3391             passphrase = get_last_passphrase();
3392         break;
3393     }
3394     if( rc )
3395         goto leave;
3396
3397     algo = ask_algo( 1, &use );
3398     assert(algo);
3399     nbits = ask_keysize( algo );
3400     expire = ask_expire_interval(0,NULL);
3401     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3402                                                   _("Really create? (y/N) ")))
3403         goto leave;
3404
3405     if (ask_pass)
3406         dek = do_ask_passphrase (&s2k);
3407     else if (passphrase) {
3408         s2k = xmalloc_secure( sizeof *s2k );
3409         s2k->mode = opt.s2k_mode;
3410         s2k->hash_algo = S2K_DIGEST_ALGO;
3411         set_next_passphrase( passphrase );
3412         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3413                                  NULL, NULL );
3414     }
3415
3416     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
3417                     dek, s2k, &sub_sk, expire, 1 );
3418     if( !rc )
3419         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3420     if( !rc )
3421         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3422     if( !rc ) {
3423         okay = 1;
3424         write_status_text (STATUS_KEY_CREATED, "S");
3425     }
3426
3427   leave:
3428     if( rc )
3429         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3430     xfree( passphrase );
3431     xfree( dek );
3432     xfree( s2k );
3433     /* release the copy of the (now unprotected) secret keys */
3434     if( pri_sk )
3435         free_secret_key(pri_sk);
3436     if( sub_sk )
3437         free_secret_key(sub_sk);
3438     set_next_passphrase( NULL );
3439     return okay;
3440 }
3441
3442
3443 #ifdef ENABLE_CARD_SUPPORT
3444 /* Generate a subkey on a card. */
3445 int
3446 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3447                           int keyno, const char *serialno)
3448 {
3449   int okay=0, rc=0;
3450   KBNODE node;
3451   PKT_secret_key *pri_sk = NULL, *sub_sk;
3452   int algo;
3453   unsigned int use;
3454   u32 expire;
3455   char *passphrase = NULL;
3456   u32 cur_time;
3457   struct para_data_s *para = NULL;
3458
3459   assert (keyno >= 1 && keyno <= 3);
3460
3461   para = xcalloc (1, sizeof *para + strlen (serialno) );
3462   para->key = pSERIALNO;
3463   strcpy (para->u.value, serialno);
3464
3465   /* Break out the primary secret key */
3466   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3467   if(!node)
3468     {
3469       log_error("Oops; secret key not found anymore!\n");
3470       goto leave;
3471     }
3472
3473   /* Make a copy of the sk to keep the protected one in the keyblock */
3474   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3475
3476   cur_time = make_timestamp();
3477   if (pri_sk->timestamp > cur_time)
3478     {
3479       ulong d = pri_sk->timestamp - cur_time;
3480       log_info (d==1 ? _("key has been created %lu second "
3481                          "in future (time warp or clock problem)\n")
3482                      : _("key has been created %lu seconds "
3483                          "in future (time warp or clock problem)\n"), d );
3484         if (!opt.ignore_time_conflict)
3485           {
3486             rc = G10ERR_TIME_CONFLICT;
3487             goto leave;
3488           }
3489     }
3490
3491   if (pri_sk->version < 4)
3492     {
3493       log_info (_("NOTE: creating subkeys for v3 keys "
3494                   "is not OpenPGP compliant\n"));
3495       goto leave;
3496     }
3497
3498   /* Unprotect to get the passphrase. */
3499   switch( is_secret_key_protected (pri_sk) )
3500     {
3501     case -1:
3502       rc = G10ERR_PUBKEY_ALGO;
3503       break;
3504     case 0:
3505       tty_printf("This key is not protected.\n");
3506       break;
3507     default:
3508       tty_printf("Key is protected.\n");
3509       rc = check_secret_key( pri_sk, 0 );
3510       if (!rc)
3511         passphrase = get_last_passphrase();
3512       break;
3513     }
3514   if (rc)
3515     goto leave;
3516
3517   algo = PUBKEY_ALGO_RSA;
3518   expire = ask_expire_interval (0,NULL);
3519   if (keyno == 1)
3520     use = PUBKEY_USAGE_SIG;
3521   else if (keyno == 2)
3522     use = PUBKEY_USAGE_ENC;
3523   else
3524     use = PUBKEY_USAGE_AUTH;
3525   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3526                                                _("Really create? (y/N) ")))
3527     goto leave;
3528
3529   if (passphrase)
3530     set_next_passphrase (passphrase);
3531   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock,
3532                      &sub_sk, expire, para);
3533   if (!rc)
3534     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3535   if (!rc)
3536     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3537   if (!rc)
3538     {
3539       okay = 1;
3540       write_status_text (STATUS_KEY_CREATED, "S");
3541     }
3542
3543  leave:
3544   if (rc)
3545     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3546   xfree (passphrase);
3547   /* Release the copy of the (now unprotected) secret keys. */
3548   if (pri_sk)
3549     free_secret_key (pri_sk);
3550   set_next_passphrase( NULL );
3551   release_parameter_list (para);
3552   return okay;
3553 }
3554 #endif /* !ENABLE_CARD_SUPPORT */
3555
3556
3557 /****************
3558  * Write a keyblock to an output stream
3559  */
3560 static int
3561 write_keyblock( IOBUF out, KBNODE node )
3562 {
3563   for( ; node ; node = node->next )
3564     {
3565       if(!is_deleted_kbnode(node))
3566         {
3567           int rc = build_packet( out, node->pkt );
3568           if( rc )
3569             {
3570               log_error("build_packet(%d) failed: %s\n",
3571                         node->pkt->pkttype, g10_errstr(rc) );
3572               return rc;
3573             }
3574         }
3575     }
3576
3577   return 0;
3578 }
3579
3580
3581 static int
3582 gen_card_key (int algo, int keyno, int is_primary,
3583               KBNODE pub_root, KBNODE sec_root, PKT_secret_key **ret_sk,
3584               u32 expireval, struct para_data_s *para)
3585 {
3586 #ifdef ENABLE_CARD_SUPPORT
3587   int rc;
3588   const char *s;
3589   struct agent_card_genkey_s info;
3590   PACKET *pkt;
3591   PKT_secret_key *sk;
3592   PKT_public_key *pk;
3593
3594   assert (algo == PUBKEY_ALGO_RSA);
3595   
3596   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
3597   rc = agent_scd_genkey (&info, keyno, 1, NULL);
3598 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3599 /*      { */
3600 /*        tty_printf ("\n"); */
3601 /*        log_error ("WARNING: key does already exists!\n"); */
3602 /*        tty_printf ("\n"); */
3603 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3604 /*                                    _("Replace existing key? "))) */
3605 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3606 /*      } */
3607
3608   if (rc)
3609     {
3610       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3611       return rc;
3612     }
3613   if ( !info.n || !info.e )
3614     {
3615       log_error ("communication error with SCD\n");
3616       mpi_free (info.n);
3617       mpi_free (info.e);
3618       return gpg_error (GPG_ERR_GENERAL);
3619     }
3620   
3621
3622   pk = xcalloc (1, sizeof *pk );
3623   sk = xcalloc (1, sizeof *sk );
3624   sk->timestamp = pk->timestamp = info.created_at;
3625   sk->version = pk->version = 4;
3626   if (expireval)
3627       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3628   sk->pubkey_algo = pk->pubkey_algo = algo;
3629   pk->pkey[0] = info.n;
3630   pk->pkey[1] = info.e; 
3631   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
3632   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
3633   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3634   sk->is_protected = 1;
3635   sk->protect.s2k.mode = 1002;
3636   s = get_parameter_value (para, pSERIALNO);
3637   if (s)
3638     {
3639       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3640            sk->protect.ivlen++, s += 2)
3641         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3642     }
3643
3644   if( ret_sk )
3645     *ret_sk = sk;
3646
3647   pkt = xcalloc (1,sizeof *pkt);
3648   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3649   pkt->pkt.public_key = pk;
3650   add_kbnode(pub_root, new_kbnode( pkt ));
3651
3652   pkt = xcalloc (1,sizeof *pkt);
3653   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3654   pkt->pkt.secret_key = sk;
3655   add_kbnode(sec_root, new_kbnode( pkt ));
3656
3657   return 0;
3658 #else
3659   return -1;
3660 #endif /*!ENABLE_CARD_SUPPORT*/
3661 }
3662
3663
3664
3665 static int
3666 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3667                           KBNODE pub_root, KBNODE sec_root,
3668                           u32 expireval, struct para_data_s *para,
3669                           const char *backup_dir)
3670 {
3671 #ifdef ENABLE_CARD_SUPPORT
3672   int rc;
3673   const char *s;
3674   PACKET *pkt;
3675   PKT_secret_key *sk, *sk_unprotected, *sk_protected;
3676   PKT_public_key *pk;
3677   size_t n;
3678   int i;
3679
3680   rc = generate_raw_key (algo, 1024, make_timestamp (),
3681                          &sk_unprotected, &sk_protected);
3682   if (rc)
3683     return rc;
3684
3685   /* First, store the key to the card. */
3686   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3687   if (rc)
3688     {
3689       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3690       free_secret_key (sk_unprotected);
3691       free_secret_key (sk_protected);
3692       return rc;
3693     }
3694
3695   /* Get rid of the secret key parameters and store the serial numer. */
3696   sk = sk_unprotected;
3697   n = pubkey_get_nskey (sk->pubkey_algo);
3698   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3699     {
3700       mpi_free (sk->skey[i]);
3701       sk->skey[i] = NULL;
3702     }
3703   i = pubkey_get_npkey (sk->pubkey_algo);
3704   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3705   sk->is_protected = 1;
3706   sk->protect.s2k.mode = 1002;
3707   s = get_parameter_value (para, pSERIALNO);
3708   assert (s);
3709   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3710        sk->protect.ivlen++, s += 2)
3711     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3712
3713   /* Now write the *protected* secret key to the file.  */
3714   {
3715     char name_buffer[50];
3716     char *fname;
3717     IOBUF fp;
3718     mode_t oldmask;
3719
3720     keyid_from_sk (sk, NULL);
3721     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
3722              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3723
3724     fname = make_filename (backup_dir, name_buffer, NULL);
3725     oldmask = umask (077);
3726     if (is_secured_filename (fname))
3727       {
3728         fp = NULL;
3729         errno = EPERM;
3730       }
3731     else
3732       fp = iobuf_create (fname);
3733     umask (oldmask);
3734     if (!fp) 
3735       {
3736         log_error (_("can't create backup file `%s': %s\n"),
3737                    fname, strerror(errno) );
3738         xfree (fname);
3739         free_secret_key (sk_unprotected);
3740         free_secret_key (sk_protected);
3741         return G10ERR_OPEN_FILE;
3742       }
3743
3744     pkt = xcalloc (1, sizeof *pkt);
3745     pkt->pkttype = PKT_SECRET_KEY;
3746     pkt->pkt.secret_key = sk_protected;
3747     sk_protected = NULL;
3748
3749     rc = build_packet (fp, pkt);
3750     if (rc)
3751       {
3752         log_error("build packet failed: %s\n", g10_errstr(rc) );
3753         iobuf_cancel (fp);
3754       }
3755     else
3756       {
3757         byte array[MAX_FINGERPRINT_LEN];
3758         char *fprbuf, *p;
3759        
3760         iobuf_close (fp);
3761         iobuf_ioctl (NULL, 2, 0, (char*)fname);
3762         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3763
3764         fingerprint_from_sk (sk, array, &n);
3765         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
3766         for (i=0; i < n ; i++, p += 2)
3767           sprintf (p, "%02X", array[i]);
3768         *p++ = ' ';
3769         *p = 0;
3770
3771         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
3772                                       fprbuf,
3773                                       fname, strlen (fname),
3774                                       0);
3775         xfree (fprbuf);
3776       }
3777     free_packet (pkt);
3778     xfree (pkt);
3779     xfree (fname);
3780     if (rc)
3781       {
3782         free_secret_key (sk_unprotected);
3783         return rc;
3784       }
3785   }
3786
3787   /* Create the public key from the secret key. */
3788   pk = xcalloc (1, sizeof *pk );
3789   pk->timestamp = sk->timestamp;
3790   pk->version = sk->version;
3791   if (expireval)
3792       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3793   pk->pubkey_algo = sk->pubkey_algo;
3794   n = pubkey_get_npkey (sk->pubkey_algo);
3795   for (i=0; i < n; i++)
3796     pk->pkey[i] = mpi_copy (sk->skey[i]);
3797
3798   /* Build packets and add them to the node lists.  */
3799   pkt = xcalloc (1,sizeof *pkt);
3800   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3801   pkt->pkt.public_key = pk;
3802   add_kbnode(pub_root, new_kbnode( pkt ));
3803
3804   pkt = xcalloc (1,sizeof *pkt);
3805   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3806   pkt->pkt.secret_key = sk;
3807   add_kbnode(sec_root, new_kbnode( pkt ));
3808
3809   return 0;
3810 #else
3811   return -1;
3812 #endif /*!ENABLE_CARD_SUPPORT*/
3813 }
3814
3815
3816 #ifdef ENABLE_CARD_SUPPORT
3817 int
3818 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3819 {
3820   int rc;
3821   unsigned char *rsa_n = NULL;
3822   unsigned char *rsa_e = NULL;
3823   unsigned char *rsa_p = NULL;
3824   unsigned char *rsa_q = NULL;
3825   unsigned int rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3826   unsigned char *sexp = NULL;
3827   unsigned char *p;
3828   char numbuf[55], numbuf2[50];
3829
3830   assert (is_RSA (sk->pubkey_algo));
3831   assert (!sk->is_protected);
3832
3833   /* Copy the parameters into straight buffers. */
3834   rsa_n = mpi_get_secure_buffer (sk->skey[0], &rsa_n_len, NULL);
3835   rsa_e = mpi_get_secure_buffer (sk->skey[1], &rsa_e_len, NULL);
3836   rsa_p = mpi_get_secure_buffer (sk->skey[3], &rsa_p_len, NULL);
3837   rsa_q = mpi_get_secure_buffer (sk->skey[4], &rsa_q_len, NULL);
3838   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
3839     {
3840       rc = G10ERR_INV_ARG;
3841       goto leave;
3842     }
3843
3844   /* Put the key into an S-expression. */
3845   sexp = p = xmalloc_secure (30
3846                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
3847                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
3848
3849   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
3850   sprintf (numbuf, "%u:", rsa_n_len);
3851   p = stpcpy (p, numbuf);
3852   memcpy (p, rsa_n, rsa_n_len);
3853   p += rsa_n_len;
3854
3855   sprintf (numbuf, ")(1:e%u:", rsa_e_len);
3856   p = stpcpy (p, numbuf);
3857   memcpy (p, rsa_e, rsa_e_len);
3858   p += rsa_e_len;
3859
3860   sprintf (numbuf, ")(1:p%u:", rsa_p_len);
3861   p = stpcpy (p, numbuf);
3862   memcpy (p, rsa_p, rsa_p_len);
3863   p += rsa_p_len;
3864
3865   sprintf (numbuf, ")(1:q%u:", rsa_q_len);
3866   p = stpcpy (p, numbuf);
3867   memcpy (p, rsa_q, rsa_q_len);
3868   p += rsa_q_len;
3869
3870   p = stpcpy (p,"))(10:created-at");
3871   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
3872   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
3873   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
3874
3875   /* Fixme: Unfortunately we don't have the serialnumber available -
3876      thus we can't pass it down to the agent. */ 
3877   rc = agent_scd_writekey (keyno, NULL, sexp, p - sexp);
3878
3879  leave:
3880   xfree (sexp);
3881   xfree (rsa_n);
3882   xfree (rsa_e);
3883   xfree (rsa_p);
3884   xfree (rsa_q);
3885   return rc;
3886 }
3887 #endif /*ENABLE_CARD_SUPPORT*/