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