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