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