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