* gpg.sgml: Document "addcardkey" and "keytocard".
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - generate a key pair
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <errno.h>
28 #include <assert.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <unistd.h>
32 #include "util.h"
33 #include "main.h"
34 #include "packet.h"
35 #include "cipher.h"
36 #include "ttyio.h"
37 #include "options.h"
38 #include "keydb.h"
39 #include "trustdb.h"
40 #include "status.h"
41 #include "i18n.h"
42 #include "cardglue.h"
43
44 #define MAX_PREFS 30 
45
46 enum para_name {
47   pKEYTYPE,
48   pKEYLENGTH,
49   pKEYUSAGE,
50   pSUBKEYTYPE,
51   pSUBKEYLENGTH,
52   pSUBKEYUSAGE,
53   pAUTHKEYTYPE,
54   pNAMEREAL,
55   pNAMEEMAIL,
56   pNAMECOMMENT,
57   pPREFERENCES,
58   pREVOKER,
59   pUSERID,
60   pEXPIREDATE,
61   pKEYEXPIRE, /* in n seconds */
62   pSUBKEYEXPIRE, /* in n seconds */
63   pPASSPHRASE,
64   pPASSPHRASE_DEK,
65   pPASSPHRASE_S2K,
66   pSERIALNO
67 };
68
69 struct para_data_s {
70     struct para_data_s *next;
71     int lnr;
72     enum para_name key;
73     union {
74         DEK *dek;
75         STRING2KEY *s2k;
76         u32 expire;
77         unsigned int usage;
78         struct revocation_key revkey;
79         char value[1];
80     } u;
81 };
82
83 struct output_control_s {
84     int lnr;
85     int dryrun;
86     int use_files;
87     struct {
88         char  *fname;
89         char  *newfname;
90         IOBUF stream;
91         armor_filter_context_t afx;
92     } pub;
93     struct {
94         char  *fname;
95         char  *newfname;
96         IOBUF stream;
97         armor_filter_context_t afx;
98     } sec;
99 };
100
101
102 struct opaque_data_usage_and_pk {
103     unsigned int usage;
104     PKT_public_key *pk;
105 };
106
107
108 static int prefs_initialized = 0;
109 static byte sym_prefs[MAX_PREFS];
110 static int nsym_prefs;
111 static byte hash_prefs[MAX_PREFS];
112 static int nhash_prefs;
113 static byte zip_prefs[MAX_PREFS];
114 static int nzip_prefs;
115 static int mdc_available,ks_modify;
116
117 static void do_generate_keypair( struct para_data_s *para,
118                                  struct output_control_s *outctrl, int card );
119 static int  write_keyblock( IOBUF out, KBNODE node );
120 static int gen_card_key (int algo, int keyno, int is_primary,
121                          KBNODE pub_root, KBNODE sec_root,
122                          u32 expireval, struct para_data_s *para);
123
124 static void
125 write_uid( KBNODE root, const char *s )
126 {
127     PACKET *pkt = m_alloc_clear(sizeof *pkt );
128     size_t n = strlen(s);
129
130     pkt->pkttype = PKT_USER_ID;
131     pkt->pkt.user_id = m_alloc_clear( sizeof *pkt->pkt.user_id + n - 1 );
132     pkt->pkt.user_id->len = n;
133     pkt->pkt.user_id->ref = 1;
134     strcpy(pkt->pkt.user_id->name, s);
135     add_kbnode( root, new_kbnode( pkt ) );
136 }
137
138 static void
139 do_add_key_flags (PKT_signature *sig, unsigned int use)
140 {
141     byte buf[1];
142
143     if (!use) 
144         return;
145
146     buf[0] = 0;
147     if (use & PUBKEY_USAGE_SIG)
148       {
149         if(sig->sig_class==0x18)
150           buf[0] |= 0x02; /* Don't set the certify flag for subkeys */
151         else
152           buf[0] |= 0x01 | 0x02;
153       }
154     if (use & PUBKEY_USAGE_ENC)
155         buf[0] |= 0x04 | 0x08;
156     if (use & PUBKEY_USAGE_AUTH)
157         buf[0] |= 0x20;
158     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
159 }
160
161
162 int
163 keygen_add_key_expire( PKT_signature *sig, void *opaque )
164 {
165     PKT_public_key *pk = opaque;
166     byte buf[8];
167     u32  u;
168
169     if( pk->expiredate ) {
170         if(pk->expiredate > pk->timestamp)
171           u= pk->expiredate - pk->timestamp;
172         else
173           u= 0;
174
175         buf[0] = (u >> 24) & 0xff;
176         buf[1] = (u >> 16) & 0xff;
177         buf[2] = (u >>  8) & 0xff;
178         buf[3] = u & 0xff;
179         build_sig_subpkt( sig, SIGSUBPKT_KEY_EXPIRE, buf, 4 );
180     }
181     else
182       {
183         /* Make sure we don't leave a key expiration subpacket lying
184            around */
185         delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
186       }
187
188     return 0;
189 }
190
191 static int
192 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
193 {
194     struct opaque_data_usage_and_pk *oduap = opaque;
195
196     do_add_key_flags (sig, oduap->usage);
197     return keygen_add_key_expire (sig, oduap->pk);
198 }
199
200 static int
201 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
202 {
203     int i;
204
205     for (i=0; i < *nbuf; i++ )
206       if (buf[i] == val)
207         {
208           log_info (_("preference `%s' duplicated\n"), item);
209           return -1;
210         }
211
212     if (*nbuf >= MAX_PREFS)
213       {
214         if(type==1)
215           log_info(_("too many cipher preferences\n"));
216         else if(type==2)
217           log_info(_("too many digest preferences\n"));
218         else if(type==3)
219           log_info(_("too many compression preferences\n"));
220         else
221           BUG();
222
223         return -1;
224       }
225
226     buf[(*nbuf)++] = val;
227     return 0;
228 }
229
230 /*
231  * Parse the supplied string and use it to set the standard
232  * preferences.  The string may be in a form like the one printed by
233  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
234  * cipher/hash/compress names.  Use NULL to set the default
235  * preferences.  Returns: 0 = okay
236  */
237 int
238 keygen_set_std_prefs (const char *string,int personal)
239 {
240     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
241     int nsym=0, nhash=0, nzip=0, val, rc=0;
242     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
243     char dummy_string[45]; /* enough for 15 items */
244
245     if (!string || !ascii_strcasecmp (string, "default"))
246       {
247         if (opt.def_preference_list)
248           string=opt.def_preference_list;
249         else
250           {
251             dummy_string[0]='\0';
252
253             /* Make sure we do not add more than 15 items here, as we
254                could overflow the size of dummy_string. */
255             if(!check_cipher_algo(CIPHER_ALGO_AES256))
256               strcat(dummy_string,"S9 ");
257             if(!check_cipher_algo(CIPHER_ALGO_AES192))
258               strcat(dummy_string,"S8 ");
259             if(!check_cipher_algo(CIPHER_ALGO_AES))
260               strcat(dummy_string,"S7 ");
261             if(!check_cipher_algo(CIPHER_ALGO_CAST5))
262               strcat(dummy_string,"S3 ");
263             strcat(dummy_string,"S2 "); /* 3DES */
264             /* If we have it, IDEA goes *after* 3DES so it won't be
265                used unless we're encrypting along with a V3 key.
266                Ideally, we would only put the S1 preference in if the
267                key was RSA and <=2048 bits, as that is what won't
268                break PGP2, but that is difficult with the current
269                code, and not really worth checking as a non-RSA <=2048
270                bit key wouldn't be usable by PGP2 anyway. -dms */
271             if(!check_cipher_algo(CIPHER_ALGO_IDEA))
272               strcat(dummy_string,"S1 ");
273
274             /* SHA-1, RIPEMD160, ZLIB, ZIP */
275             strcat(dummy_string,"H2 H3 Z2 Z1");
276
277             string=dummy_string;
278           }
279       }
280     else if (!ascii_strcasecmp (string, "none"))
281         string = "";
282
283     if(strlen(string))
284       {
285         char *tok,*prefstring;
286
287         prefstring=m_strdup(string); /* need a writable string! */
288
289         while((tok=strsep(&prefstring," ,")))
290           {
291             if((val=string_to_cipher_algo(tok)))
292               {
293                 if(set_one_pref(val,1,tok,sym,&nsym))
294                   rc=-1;
295               }
296             else if((val=string_to_digest_algo(tok)))
297               {
298                 if(set_one_pref(val,2,tok,hash,&nhash))
299                   rc=-1;
300               }
301             else if((val=string_to_compress_algo(tok))>-1)
302               {
303                 if(set_one_pref(val,3,tok,zip,&nzip))
304                   rc=-1;
305               }
306             else if (ascii_strcasecmp(tok,"mdc")==0)
307               mdc=1;
308             else if (ascii_strcasecmp(tok,"no-mdc")==0)
309               mdc=0;
310             else if (ascii_strcasecmp(tok,"ks-modify")==0)
311               modify=1;
312             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
313               modify=0;
314             else
315               {
316                 log_info (_("invalid item `%s' in preference string\n"),tok);
317
318                 /* Complain if IDEA is not available. */
319                 if(ascii_strcasecmp(tok,"s1")==0
320                    || ascii_strcasecmp(tok,"idea")==0)
321                   idea_cipher_warn(1);
322
323                 rc=-1;
324               }
325           }
326
327         m_free(prefstring);
328       }
329
330     if(!rc)
331       {
332         if(personal)
333           {
334             if(personal==PREFTYPE_SYM)
335               {
336                 m_free(opt.personal_cipher_prefs);
337
338                 if(nsym==0)
339                   opt.personal_cipher_prefs=NULL;
340                 else
341                   {
342                     int i;
343
344                     opt.personal_cipher_prefs=
345                       m_alloc(sizeof(prefitem_t *)*(nsym+1));
346
347                     for (i=0; i<nsym; i++)
348                       {
349                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
350                         opt.personal_cipher_prefs[i].value = sym[i];
351                       }
352
353                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
354                     opt.personal_cipher_prefs[i].value = 0;
355                   }
356               }
357             else if(personal==PREFTYPE_HASH)
358               {
359                 m_free(opt.personal_digest_prefs);
360
361                 if(nhash==0)
362                   opt.personal_digest_prefs=NULL;
363                 else
364                   {
365                     int i;
366
367                     opt.personal_digest_prefs=
368                       m_alloc(sizeof(prefitem_t *)*(nhash+1));
369
370                     for (i=0; i<nhash; i++)
371                       {
372                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
373                         opt.personal_digest_prefs[i].value = hash[i];
374                       }
375
376                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
377                     opt.personal_digest_prefs[i].value = 0;
378                   }
379               }
380             else if(personal==PREFTYPE_ZIP)
381               {
382                 m_free(opt.personal_compress_prefs);
383
384                 if(nzip==0)
385                   opt.personal_compress_prefs=NULL;
386                 else
387                   {
388                     int i;
389
390                     opt.personal_compress_prefs=
391                       m_alloc(sizeof(prefitem_t *)*(nzip+1));
392
393                     for (i=0; i<nzip; i++)
394                       {
395                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
396                         opt.personal_compress_prefs[i].value = zip[i];
397                       }
398
399                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
400                     opt.personal_compress_prefs[i].value = 0;
401                   }
402               }
403           }
404         else
405           {
406             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
407             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
408             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
409             mdc_available = mdc;
410             ks_modify = modify;
411             prefs_initialized = 1;
412           }
413       }
414
415     return rc;
416 }
417
418 /* Return a fake user ID containing the preferences.  Caller must
419    free. */
420 PKT_user_id *keygen_get_std_prefs(void)
421 {
422   int i,j=0;
423   PKT_user_id *uid=m_alloc_clear(sizeof(PKT_user_id));
424
425   if(!prefs_initialized)
426     keygen_set_std_prefs(NULL,0);
427
428   uid->prefs=m_alloc((sizeof(prefitem_t *)*
429                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
430
431   for(i=0;i<nsym_prefs;i++,j++)
432     {
433       uid->prefs[j].type=PREFTYPE_SYM;
434       uid->prefs[j].value=sym_prefs[i];
435     }
436
437   for(i=0;i<nhash_prefs;i++,j++)
438     {
439       uid->prefs[j].type=PREFTYPE_HASH;
440       uid->prefs[j].value=hash_prefs[i];
441     }
442
443   for(i=0;i<nzip_prefs;i++,j++)
444     {
445       uid->prefs[j].type=PREFTYPE_ZIP;
446       uid->prefs[j].value=zip_prefs[i];
447     }
448
449   uid->prefs[j].type=PREFTYPE_NONE;
450   uid->prefs[j].value=0;
451
452   uid->mdc_feature=mdc_available;
453   uid->ks_modify=ks_modify;
454
455   return uid;
456 }
457
458 static void
459 add_feature_mdc (PKT_signature *sig,int enabled)
460 {
461     const byte *s;
462     size_t n;
463     int i;
464     char *buf;
465
466     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
467     /* Already set or cleared */
468     if (s && n &&
469         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
470       return;
471
472     if (!s || !n) { /* create a new one */
473         n = 1;
474         buf = m_alloc_clear (n);
475     }
476     else {
477         buf = m_alloc (n);
478         memcpy (buf, s, n);
479     }
480
481     if(enabled)
482       buf[0] |= 0x01; /* MDC feature */
483     else
484       buf[0] &= ~0x01;
485
486     /* Are there any bits set? */
487     for(i=0;i<n;i++)
488       if(buf[i]!=0)
489         break;
490
491     if(i==n)
492       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
493     else
494       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
495
496     m_free (buf);
497 }
498
499 static void
500 add_keyserver_modify (PKT_signature *sig,int enabled)
501 {
502   const byte *s;
503   size_t n;
504   int i;
505   char *buf;
506
507   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
508   enabled=!enabled;
509
510   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
511   /* Already set or cleared */
512   if (s && n &&
513       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
514     return;
515
516   if (!s || !n) { /* create a new one */
517     n = 1;
518     buf = m_alloc_clear (n);
519   }
520   else {
521     buf = m_alloc (n);
522     memcpy (buf, s, n);
523   }
524
525   if(enabled)
526     buf[0] |= 0x80; /* no-modify flag */
527   else
528     buf[0] &= ~0x80;
529
530   /* Are there any bits set? */
531   for(i=0;i<n;i++)
532     if(buf[i]!=0)
533       break;
534
535   if(i==n)
536     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
537   else
538     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
539
540   m_free (buf);
541 }
542
543 int
544 keygen_upd_std_prefs( PKT_signature *sig, void *opaque )
545 {
546     if (!prefs_initialized)
547         keygen_set_std_prefs (NULL, 0);
548
549     if (nsym_prefs) 
550         build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
551     else
552       {
553         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
554         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
555       }
556
557     if (nhash_prefs)
558         build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
559     else
560       {
561         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
562         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
563       }
564
565     if (nzip_prefs)
566         build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
567     else
568       {
569         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
570         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
571       }
572
573     /* Make sure that the MDC feature flag is set if needed */
574     add_feature_mdc (sig,mdc_available);
575     add_keyserver_modify (sig,ks_modify);
576
577     return 0;
578 }
579
580
581 /****************
582  * Add preference to the self signature packet.
583  * This is only called for packets with version > 3.
584
585  */
586 int
587 keygen_add_std_prefs( PKT_signature *sig, void *opaque )
588 {
589     PKT_public_key *pk = opaque;
590
591     do_add_key_flags (sig, pk->pubkey_usage);
592     keygen_add_key_expire( sig, opaque );
593     keygen_upd_std_prefs (sig, opaque);
594
595     return 0;
596 }
597
598 int
599 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
600 {
601   const char *url=opaque;
602
603   if(url)
604     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
605   else
606     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
607
608   return 0;
609 }
610
611 int
612 keygen_add_revkey(PKT_signature *sig, void *opaque)
613 {
614   struct revocation_key *revkey=opaque;
615   byte buf[2+MAX_FINGERPRINT_LEN];
616
617   buf[0]=revkey->class;
618   buf[1]=revkey->algid;
619   memcpy(&buf[2],revkey->fpr,MAX_FINGERPRINT_LEN);
620
621   build_sig_subpkt(sig,SIGSUBPKT_REV_KEY,buf,2+MAX_FINGERPRINT_LEN);
622
623   /* All sigs with revocation keys set are nonrevocable */
624   sig->flags.revocable=0;
625   buf[0] = 0;
626   build_sig_subpkt( sig, SIGSUBPKT_REVOCABLE, buf, 1 );
627
628   parse_revkeys(sig);
629
630   return 0;
631 }
632
633 static int
634 make_backsig(PKT_signature *sig, PKT_public_key *pk,
635              PKT_public_key *sub_pk, PKT_secret_key *sub_sk)
636 {
637   PKT_signature *backsig;
638   int rc;
639
640 #ifndef DO_BACKSIGS
641   /* This is not enabled yet, as I want to get a bit closer to RFC day
642      before enabling this.  I've been burned before :) */
643
644   return 0;
645 #endif
646
647   cache_public_key (sub_pk);
648
649   rc=make_keysig_packet(&backsig,pk,NULL,sub_pk,sub_sk, 0x19, 0, 0, 0, 0,
650                         NULL,NULL);
651   if( rc )
652     log_error("make_keysig_packet failed for backsig: %s\n", g10_errstr(rc) );
653   else
654     {
655       /* get it into a binary packed form. */
656       IOBUF backsig_out=iobuf_temp();
657       PACKET backsig_pkt;
658  
659       init_packet(&backsig_pkt);
660       backsig_pkt.pkttype=PKT_SIGNATURE;
661       backsig_pkt.pkt.signature=backsig;
662       rc=build_packet(backsig_out,&backsig_pkt);
663       free_packet(&backsig_pkt);
664       if(rc)
665         log_error("build_packet failed for backsig: %s\n",g10_errstr(rc));
666       else
667         {
668           size_t pktlen=0;
669           byte *buf=iobuf_get_temp_buffer(backsig_out);
670  
671           /* Remove the packet header */
672           if(buf[0]&0x40)
673             {
674               if(buf[1]<192)
675                 {
676                   pktlen=buf[1];
677                   buf+=2;
678                 }
679               else if(buf[1]<224)
680                 {
681                   pktlen=(buf[1]-192)*256;
682                   pktlen+=buf[2]+192;
683                   buf+=3;
684                 }
685               else if(buf[1]==255)
686                 {
687                   pktlen =buf[2] << 24;
688                   pktlen|=buf[3] << 16;
689                   pktlen|=buf[4] << 8;
690                   pktlen|=buf[5];
691                   buf+=6;
692                 }
693               else
694                 BUG();
695             }
696           else
697             {
698               int mark=1;
699  
700               switch(buf[0]&3)
701                 {
702                 case 3:
703                   BUG();
704                   break;
705  
706                 case 2:
707                   pktlen =buf[mark++] << 24;
708                   pktlen|=buf[mark++] << 16;
709  
710                 case 1:
711                   pktlen|=buf[mark++] << 8;
712  
713                 case 0:
714                   pktlen|=buf[mark++];
715                 }
716  
717               buf+=mark;
718             }
719  
720           /* now make the binary blob into a subpacket */
721           build_sig_subpkt(sig,SIGSUBPKT_SIGNATURE,buf,pktlen);
722
723           iobuf_close(backsig_out);
724         }
725     }
726  
727   return rc;
728 }
729
730
731 static int
732 write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
733                   struct revocation_key *revkey )
734 {
735     PACKET *pkt;
736     PKT_signature *sig;
737     int rc=0;
738     KBNODE node;
739     PKT_public_key *pk;
740
741     if( opt.verbose )
742         log_info(_("writing direct signature\n"));
743
744     /* get the pk packet from the pub_tree */
745     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
746     if( !node )
747         BUG();
748     pk = node->pkt->pkt.public_key;
749
750     /* we have to cache the key, so that the verification of the signature
751      * creation is able to retrieve the public key */
752     cache_public_key (pk);
753
754     /* and make the signature */
755     rc = make_keysig_packet(&sig,pk,NULL,NULL,sk,0x1F,0,0,0,0,
756                             keygen_add_revkey,revkey);
757     if( rc ) {
758         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
759         return rc;
760     }
761
762     pkt = m_alloc_clear( sizeof *pkt );
763     pkt->pkttype = PKT_SIGNATURE;
764     pkt->pkt.signature = sig;
765     add_kbnode( root, new_kbnode( pkt ) );
766     return rc;
767 }
768
769 static int
770 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
771                unsigned int use )
772 {
773     PACKET *pkt;
774     PKT_signature *sig;
775     PKT_user_id *uid;
776     int rc=0;
777     KBNODE node;
778     PKT_public_key *pk;
779
780     if( opt.verbose )
781         log_info(_("writing self signature\n"));
782
783     /* get the uid packet from the list */
784     node = find_kbnode( root, PKT_USER_ID );
785     if( !node )
786         BUG(); /* no user id packet in tree */
787     uid = node->pkt->pkt.user_id;
788     /* get the pk packet from the pub_tree */
789     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
790     if( !node )
791         BUG();
792     pk = node->pkt->pkt.public_key;
793     pk->pubkey_usage = use;
794     /* we have to cache the key, so that the verification of the signature
795      * creation is able to retrieve the public key */
796     cache_public_key (pk);
797
798     /* and make the signature */
799     rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0, 0, 0, 0,
800                              keygen_add_std_prefs, pk );
801     if( rc ) {
802         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
803         return rc;
804     }
805
806     pkt = m_alloc_clear( sizeof *pkt );
807     pkt->pkttype = PKT_SIGNATURE;
808     pkt->pkt.signature = sig;
809     add_kbnode( root, new_kbnode( pkt ) );
810     return rc;
811 }
812
813 /* sub_sk is currently unused (reserved for backsigs) */
814 static int
815 write_keybinding( KBNODE root, KBNODE pub_root,
816                   PKT_secret_key *pri_sk, PKT_secret_key *sub_sk,
817                   unsigned int use )
818 {
819     PACKET *pkt;
820     PKT_signature *sig;
821     int rc=0;
822     KBNODE node;
823     PKT_public_key *pri_pk, *sub_pk;
824     struct opaque_data_usage_and_pk oduap;
825
826     if( opt.verbose )
827         log_info(_("writing key binding signature\n"));
828
829     /* get the pk packet from the pub_tree */
830     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
831     if( !node )
832         BUG();
833     pri_pk = node->pkt->pkt.public_key;
834     /* we have to cache the key, so that the verification of the signature
835      * creation is able to retrieve the public key */
836     cache_public_key (pri_pk);
837  
838     /* find the last subkey */
839     sub_pk = NULL;
840     for(node=pub_root; node; node = node->next ) {
841         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
842             sub_pk = node->pkt->pkt.public_key;
843     }
844     if( !sub_pk )
845         BUG();
846
847     /* and make the signature */
848     oduap.usage = use;
849     oduap.pk = sub_pk;
850     rc=make_keysig_packet(&sig, pri_pk, NULL, sub_pk, pri_sk, 0x18, 0, 0, 0, 0,
851                           keygen_add_key_flags_and_expire, &oduap );
852     if( rc ) {
853         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
854         return rc;
855     }
856
857     /* make a backsig */
858     if(use&PUBKEY_USAGE_SIG)
859       {
860         rc=make_backsig(sig,pri_pk,sub_pk,sub_sk);
861         if(rc)
862           return rc;
863       }
864
865     pkt = m_alloc_clear( sizeof *pkt );
866     pkt->pkttype = PKT_SIGNATURE;
867     pkt->pkt.signature = sig;
868     add_kbnode( root, new_kbnode( pkt ) );
869     return rc;
870 }
871
872
873 static int
874 gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
875         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
876 {
877     int rc;
878     int i;
879     PACKET *pkt;
880     PKT_secret_key *sk;
881     PKT_public_key *pk;
882     MPI skey[4];
883     MPI *factors;
884
885     assert( is_ELGAMAL(algo) );
886
887     if( nbits < 512 ) {
888         nbits = 1024;
889         log_info(_("keysize invalid; using %u bits\n"), nbits );
890     }
891
892     if( (nbits % 32) ) {
893         nbits = ((nbits + 31) / 32) * 32;
894         log_info(_("keysize rounded up to %u bits\n"), nbits );
895     }
896
897     rc = pubkey_generate( algo, nbits, skey, &factors );
898     if( rc ) {
899         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
900         return rc;
901     }
902
903     sk = m_alloc_clear( sizeof *sk );
904     pk = m_alloc_clear( sizeof *pk );
905     sk->timestamp = pk->timestamp = make_timestamp();
906     sk->version = pk->version = 4;
907     if( expireval ) {
908         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
909     }
910     sk->pubkey_algo = pk->pubkey_algo = algo;
911                        pk->pkey[0] = mpi_copy( skey[0] );
912                        pk->pkey[1] = mpi_copy( skey[1] );
913                        pk->pkey[2] = mpi_copy( skey[2] );
914     sk->skey[0] = skey[0];
915     sk->skey[1] = skey[1];
916     sk->skey[2] = skey[2];
917     sk->skey[3] = skey[3];
918     sk->is_protected = 0;
919     sk->protect.algo = 0;
920
921     sk->csum = checksum_mpi( sk->skey[3] );
922     if( ret_sk ) /* return an unprotected version of the sk */
923         *ret_sk = copy_secret_key( NULL, sk );
924
925     if( dek ) {
926         sk->protect.algo = dek->algo;
927         sk->protect.s2k = *s2k;
928         rc = protect_secret_key( sk, dek );
929         if( rc ) {
930             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
931             free_public_key(pk);
932             free_secret_key(sk);
933             return rc;
934         }
935     }
936
937     pkt = m_alloc_clear(sizeof *pkt);
938     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
939     pkt->pkt.public_key = pk;
940     add_kbnode(pub_root, new_kbnode( pkt ));
941
942     /* don't know whether it makes sense to have the factors, so for now
943      * we store them in the secret keyring (but they are not secret) */
944     pkt = m_alloc_clear(sizeof *pkt);
945     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
946     pkt->pkt.secret_key = sk;
947     add_kbnode(sec_root, new_kbnode( pkt ));
948     for(i=0; factors[i]; i++ )
949         add_kbnode( sec_root,
950                     make_mpi_comment_node("#:ELG_factor:", factors[i] ));
951
952     return 0;
953 }
954
955
956 /****************
957  * Generate a DSA key
958  */
959 static int
960 gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
961         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
962 {
963     int rc;
964     int i;
965     PACKET *pkt;
966     PKT_secret_key *sk;
967     PKT_public_key *pk;
968     MPI skey[5];
969     MPI *factors;
970
971     if( nbits > 1024 || nbits < 512 ) {
972         nbits = 1024;
973         log_info(_("keysize invalid; using %u bits\n"), nbits );
974     }
975
976     if( (nbits % 64) ) {
977         nbits = ((nbits + 63) / 64) * 64;
978         log_info(_("keysize rounded up to %u bits\n"), nbits );
979     }
980
981     rc = pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors );
982     if( rc ) {
983         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
984         return rc;
985     }
986
987     sk = m_alloc_clear( sizeof *sk );
988     pk = m_alloc_clear( sizeof *pk );
989     sk->timestamp = pk->timestamp = make_timestamp();
990     sk->version = pk->version = 4;
991     if( expireval ) {
992         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
993     }
994     sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
995                        pk->pkey[0] = mpi_copy( skey[0] );
996                        pk->pkey[1] = mpi_copy( skey[1] );
997                        pk->pkey[2] = mpi_copy( skey[2] );
998                        pk->pkey[3] = mpi_copy( skey[3] );
999     sk->skey[0] = skey[0];
1000     sk->skey[1] = skey[1];
1001     sk->skey[2] = skey[2];
1002     sk->skey[3] = skey[3];
1003     sk->skey[4] = skey[4];
1004     sk->is_protected = 0;
1005     sk->protect.algo = 0;
1006
1007     sk->csum = checksum_mpi ( sk->skey[4] );
1008     if( ret_sk ) /* return an unprotected version of the sk */
1009         *ret_sk = copy_secret_key( NULL, sk );
1010
1011     if( dek ) {
1012         sk->protect.algo = dek->algo;
1013         sk->protect.s2k = *s2k;
1014         rc = protect_secret_key( sk, dek );
1015         if( rc ) {
1016             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1017             free_public_key(pk);
1018             free_secret_key(sk);
1019             return rc;
1020         }
1021     }
1022
1023     pkt = m_alloc_clear(sizeof *pkt);
1024     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1025     pkt->pkt.public_key = pk;
1026     add_kbnode(pub_root, new_kbnode( pkt ));
1027
1028     /* don't know whether it makes sense to have the factors, so for now
1029      * we store them in the secret keyring (but they are not secret)
1030      * p = 2 * q * f1 * f2 * ... * fn
1031      * We store only f1 to f_n-1;  fn can be calculated because p and q
1032      * are known.
1033      */
1034     pkt = m_alloc_clear(sizeof *pkt);
1035     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1036     pkt->pkt.secret_key = sk;
1037     add_kbnode(sec_root, new_kbnode( pkt ));
1038     for(i=1; factors[i]; i++ )  /* the first one is q */
1039         add_kbnode( sec_root,
1040                     make_mpi_comment_node("#:DSA_factor:", factors[i] ));
1041
1042     return 0;
1043 }
1044
1045
1046 /* 
1047  * Generate an RSA key.
1048  */
1049 static int
1050 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1051         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
1052 {
1053     int rc;
1054     PACKET *pkt;
1055     PKT_secret_key *sk;
1056     PKT_public_key *pk;
1057     MPI skey[6];
1058     MPI *factors;
1059
1060     assert( is_RSA(algo) );
1061
1062     if( nbits < 1024 ) {
1063         nbits = 1024;
1064         log_info(_("keysize invalid; using %u bits\n"), nbits );
1065     }
1066
1067     if( (nbits % 32) ) {
1068         nbits = ((nbits + 31) / 32) * 32;
1069         log_info(_("keysize rounded up to %u bits\n"), nbits );
1070     }
1071
1072     rc = pubkey_generate( algo, nbits, skey, &factors );
1073     if( rc ) {
1074         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
1075         return rc;
1076     }
1077
1078     sk = m_alloc_clear( sizeof *sk );
1079     pk = m_alloc_clear( sizeof *pk );
1080     sk->timestamp = pk->timestamp = make_timestamp();
1081     sk->version = pk->version = 4;
1082     if( expireval ) {
1083         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1084     }
1085     sk->pubkey_algo = pk->pubkey_algo = algo;
1086                        pk->pkey[0] = mpi_copy( skey[0] );
1087                        pk->pkey[1] = mpi_copy( skey[1] );
1088     sk->skey[0] = skey[0];
1089     sk->skey[1] = skey[1];
1090     sk->skey[2] = skey[2];
1091     sk->skey[3] = skey[3];
1092     sk->skey[4] = skey[4];
1093     sk->skey[5] = skey[5];
1094     sk->is_protected = 0;
1095     sk->protect.algo = 0;
1096
1097     sk->csum  = checksum_mpi (sk->skey[2] );
1098     sk->csum += checksum_mpi (sk->skey[3] );
1099     sk->csum += checksum_mpi (sk->skey[4] );
1100     sk->csum += checksum_mpi (sk->skey[5] );
1101     if( ret_sk ) /* return an unprotected version of the sk */
1102         *ret_sk = copy_secret_key( NULL, sk );
1103
1104     if( dek ) {
1105         sk->protect.algo = dek->algo;
1106         sk->protect.s2k = *s2k;
1107         rc = protect_secret_key( sk, dek );
1108         if( rc ) {
1109             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
1110             free_public_key(pk);
1111             free_secret_key(sk);
1112             return rc;
1113         }
1114     }
1115
1116     pkt = m_alloc_clear(sizeof *pkt);
1117     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1118     pkt->pkt.public_key = pk;
1119     add_kbnode(pub_root, new_kbnode( pkt ));
1120
1121     pkt = m_alloc_clear(sizeof *pkt);
1122     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1123     pkt->pkt.secret_key = sk;
1124     add_kbnode(sec_root, new_kbnode( pkt ));
1125
1126     return 0;
1127 }
1128
1129
1130 /****************
1131  * check valid days:
1132  * return 0 on error or the multiplier
1133  */
1134 static int
1135 check_valid_days( const char *s )
1136 {
1137     if( !digitp(s) )
1138         return 0;
1139     for( s++; *s; s++)
1140         if( !digitp(s) )
1141             break;
1142     if( !*s )
1143         return 1;
1144     if( s[1] )
1145         return 0; /* e.g. "2323wc" */
1146     if( *s == 'd' || *s == 'D' )
1147         return 1;
1148     if( *s == 'w' || *s == 'W' )
1149         return 7;
1150     if( *s == 'm' || *s == 'M' )
1151         return 30;
1152     if( *s == 'y' || *s == 'Y' )
1153         return 365;
1154     return 0;
1155 }
1156
1157
1158 /****************
1159  * Returns: 0 to create both a DSA and a Elgamal key.
1160  *          and only if key flags are to be written the desired usage.
1161  */
1162 static int
1163 ask_algo (int addmode, unsigned int *r_usage)
1164 {
1165     char *answer;
1166     int algo;
1167
1168     *r_usage = 0;
1169     tty_printf(_("Please select what kind of key you want:\n"));
1170     if( !addmode )
1171         tty_printf(_("   (%d) DSA and Elgamal (default)\n"), 1 );
1172     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
1173     if( addmode )
1174         tty_printf(    _("   (%d) Elgamal (encrypt only)\n"), 3 );
1175     tty_printf(    _("   (%d) RSA (sign only)\n"), 4 );
1176     if (addmode)
1177         tty_printf(    _("   (%d) RSA (encrypt only)\n"), 5 );
1178     if (opt.expert)
1179       tty_printf(    _("   (%d) RSA (sign and encrypt)\n"), 6 );
1180     if (opt.expert && addmode)
1181       tty_printf(    _("   (%d) RSA (auth only)\n"), 7 );
1182     if (opt.expert)
1183       tty_printf(    _("   (%d) RSA (sign and auth)\n"), 8 );
1184     if (opt.expert && addmode)
1185       tty_printf(    _("   (%d) RSA (encrypt and auth)\n"), 9 );
1186     if (opt.expert)
1187       tty_printf(    _("  (%d) RSA (sign, encrypt and auth)\n"), 10 );
1188
1189     for(;;) {
1190         answer = cpr_get("keygen.algo",_("Your selection? "));
1191         cpr_kill_prompt();
1192         algo = *answer? atoi(answer): 1;
1193         m_free(answer);
1194         if( algo == 1 && !addmode ) {
1195             algo = 0;   /* create both keys */
1196             break;
1197         }
1198         else if( algo == 10 && opt.expert ) {
1199             algo = PUBKEY_ALGO_RSA;
1200             *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
1201             break;
1202         }
1203         else if( algo == 9 && opt.expert && addmode) {
1204             algo = PUBKEY_ALGO_RSA;
1205             *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH;
1206             break;
1207         }
1208         else if( algo == 8 && opt.expert ) {
1209             algo = PUBKEY_ALGO_RSA;
1210             *r_usage = PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
1211             break;
1212         }
1213         else if( algo == 7 && opt.expert && addmode) {
1214             algo = PUBKEY_ALGO_RSA;
1215             *r_usage = PUBKEY_USAGE_AUTH;
1216             break;
1217         }
1218         else if( algo == 6 && opt.expert ) {
1219             algo = PUBKEY_ALGO_RSA;
1220             *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
1221             break;
1222         }
1223         else if( algo == 5 && addmode ) {
1224             algo = PUBKEY_ALGO_RSA;
1225             *r_usage = PUBKEY_USAGE_ENC;
1226             break;
1227         }
1228         else if( algo == 4 ) {
1229             algo = PUBKEY_ALGO_RSA;
1230             *r_usage = PUBKEY_USAGE_SIG;
1231             break;
1232         }
1233         else if( algo == 3 && addmode ) {
1234             algo = PUBKEY_ALGO_ELGAMAL_E;
1235             *r_usage = PUBKEY_USAGE_ENC;
1236             break;
1237         }
1238         else if( algo == 2 ) {
1239             algo = PUBKEY_ALGO_DSA;
1240             *r_usage = PUBKEY_USAGE_SIG;
1241             break;
1242         }
1243         else
1244             tty_printf(_("Invalid selection.\n"));
1245     }
1246     return algo;
1247 }
1248
1249
1250 static unsigned
1251 ask_keysize( int algo )
1252 {
1253     char *answer;
1254     unsigned nbits;
1255
1256     if (algo != PUBKEY_ALGO_DSA && algo != PUBKEY_ALGO_RSA) {
1257         tty_printf (_("About to generate a new %s keypair.\n"
1258                       "              minimum keysize is  768 bits\n"
1259                       "              default keysize is 1024 bits\n"
1260                       "    highest suggested keysize is 2048 bits\n"),
1261                     pubkey_algo_to_string(algo) );
1262     }
1263
1264     for(;;) {
1265         answer = cpr_get("keygen.size",
1266                           _("What keysize do you want? (1024) "));
1267         cpr_kill_prompt();
1268         nbits = *answer? atoi(answer): 1024;
1269         m_free(answer);
1270         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
1271             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
1272         else if( algo == PUBKEY_ALGO_RSA && nbits < 1024 )
1273             tty_printf(_("keysize too small;"
1274                          " 1024 is smallest value allowed for RSA.\n"));
1275         else if( nbits < 768 )
1276             tty_printf(_("keysize too small;"
1277                          " 768 is smallest value allowed.\n"));
1278         else if( nbits > 4096 ) {
1279             /* It is ridiculous and an annoyance to use larger key sizes!
1280              * GnuPG can handle much larger sizes; but it takes an eternity
1281              * to create such a key (but less than the time the Sirius
1282              * Computer Corporation needs to process one of the usual
1283              * complaints) and {de,en}cryption although needs some time.
1284              * So, before you complain about this limitation, I suggest that
1285              * you start a discussion with Marvin about this theme and then
1286              * do whatever you want. */
1287             tty_printf(_("keysize too large; %d is largest value allowed.\n"),
1288                                                                          4096);
1289         }
1290         else if( nbits > 2048 && !cpr_enabled() ) {
1291             tty_printf(
1292                 _("Keysizes larger than 2048 are not suggested because\n"
1293                   "computations take REALLY long!\n"));
1294             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
1295                         "Are you sure that you want this keysize? ")) ) {
1296                 tty_printf(_("Okay, but keep in mind that your monitor "
1297                              "and keyboard radiation is also very vulnerable "
1298                              "to attacks!\n"));
1299                 break;
1300             }
1301         }
1302         else
1303             break;
1304     }
1305     tty_printf(_("Requested keysize is %u bits\n"), nbits );
1306     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
1307         nbits = ((nbits + 63) / 64) * 64;
1308         tty_printf(_("rounded up to %u bits\n"), nbits );
1309     }
1310     else if( (nbits % 32) ) {
1311         nbits = ((nbits + 31) / 32) * 32;
1312         tty_printf(_("rounded up to %u bits\n"), nbits );
1313     }
1314     return nbits;
1315 }
1316
1317
1318 /****************
1319  * Parse an expire string and return it's value in days.
1320  * Returns -1 on error.
1321  */
1322 static int
1323 parse_expire_string( const char *string )
1324 {
1325     int mult;
1326     u32 abs_date=0;
1327     u32 curtime = make_timestamp();
1328     int valid_days;
1329
1330     if( !*string )
1331         valid_days = 0;
1332     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
1333         /* This calculation is not perfectly okay because we
1334          * are later going to simply multiply by 86400 and don't
1335          * correct for leapseconds.  A solution would be to change
1336          * the whole implemenation to work with dates and not intervals
1337          * which are required for v3 keys.
1338          */
1339         valid_days = abs_date/86400-curtime/86400+1;
1340     }
1341     else if( (mult=check_valid_days(string)) ) {
1342         valid_days = atoi(string) * mult;
1343         if( valid_days < 0 || valid_days > 39447 )
1344             valid_days = 0;
1345     }
1346     else {
1347         valid_days = -1;
1348     }
1349     return valid_days;
1350 }
1351
1352 /* object == 0 for a key, and 1 for a sig */
1353 u32
1354 ask_expire_interval(int object)
1355 {
1356     char *answer;
1357     int valid_days=0;
1358     u32 interval = 0;
1359
1360     switch(object)
1361       {
1362       case 0:
1363         tty_printf(_("Please specify how long the key should be valid.\n"
1364                      "         0 = key does not expire\n"
1365                      "      <n>  = key expires in n days\n"
1366                      "      <n>w = key expires in n weeks\n"
1367                      "      <n>m = key expires in n months\n"
1368                      "      <n>y = key expires in n years\n"));
1369         break;
1370
1371       case 1:
1372         tty_printf(_("Please specify how long the signature should be valid.\n"
1373                      "         0 = signature does not expire\n"
1374                      "      <n>  = signature expires in n days\n"
1375                      "      <n>w = signature expires in n weeks\n"
1376                      "      <n>m = signature expires in n months\n"
1377                      "      <n>y = signature expires in n years\n"));
1378         break;
1379
1380       default:
1381         BUG();
1382       }
1383
1384     /* Note: The elgamal subkey for DSA has no expiration date because
1385      * it must be signed with the DSA key and this one has the expiration
1386      * date */
1387
1388     answer = NULL;
1389     for(;;) {
1390         u32 curtime=make_timestamp();
1391
1392         m_free(answer);
1393         if(object==0)
1394           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1395         else
1396           answer = cpr_get("siggen.valid",_("Signature is valid for? (0) "));
1397         cpr_kill_prompt();
1398         trim_spaces(answer);
1399         valid_days = parse_expire_string( answer );
1400         if( valid_days < 0 ) {
1401             tty_printf(_("invalid value\n"));
1402             continue;
1403         }
1404
1405         if( !valid_days ) {
1406             tty_printf(_("%s does not expire at all\n"),
1407                        object==0?"Key":"Signature");
1408             interval = 0;
1409         }
1410         else {
1411             interval = valid_days * 86400L;
1412             /* print the date when the key expires */
1413             tty_printf(_("%s expires at %s\n"),
1414                         object==0?"Key":"Signature",
1415                         asctimestamp((ulong)(curtime + interval) ) );
1416             /* FIXME: This check yields warning on alhas:
1417                write a configure check and to this check here only for 32 bit machines */
1418             if( (time_t)((ulong)(curtime+interval)) < 0 )
1419                 tty_printf(_("Your system can't display dates beyond 2038.\n"
1420                     "However, it will be correctly handled up to 2106.\n"));
1421         }
1422
1423         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1424                                             _("Is this correct (y/n)? ")) )
1425             break;
1426     }
1427     m_free(answer);
1428     return interval;
1429 }
1430
1431 u32
1432 ask_expiredate()
1433 {
1434     u32 x = ask_expire_interval(0);
1435     return x? make_timestamp() + x : 0;
1436 }
1437
1438 static int
1439 has_invalid_email_chars( const char *s )
1440 {
1441     int at_seen=0;
1442     static char valid_chars[] = "01234567890_-."
1443                                 "abcdefghijklmnopqrstuvwxyz"
1444                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1445
1446     for( ; *s; s++ ) {
1447         if( *s & 0x80 )
1448             return 1;
1449         if( *s == '@' )
1450             at_seen=1;
1451         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1452             return 1;
1453         else if( at_seen && !strchr( valid_chars, *s ) )
1454             return 1;
1455     }
1456     return 0;
1457 }
1458
1459
1460 static char *
1461 ask_user_id( int mode )
1462 {
1463     char *answer;
1464     char *aname, *acomment, *amail, *uid;
1465
1466     if( !mode )
1467         tty_printf( _("\n"
1468 "You need a User-ID to identify your key; the software constructs the user id\n"
1469 "from Real Name, Comment and Email Address in this form:\n"
1470 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1471     uid = aname = acomment = amail = NULL;
1472     for(;;) {
1473         char *p;
1474         int fail=0;
1475
1476         if( !aname ) {
1477             for(;;) {
1478                 m_free(aname);
1479                 aname = cpr_get("keygen.name",_("Real name: "));
1480                 trim_spaces(aname);
1481                 cpr_kill_prompt();
1482
1483                 if( opt.allow_freeform_uid )
1484                     break;
1485
1486                 if( strpbrk( aname, "<>" ) )
1487                     tty_printf(_("Invalid character in name\n"));
1488                 else if( digitp(aname) )
1489                     tty_printf(_("Name may not start with a digit\n"));
1490                 else if( strlen(aname) < 5 )
1491                     tty_printf(_("Name must be at least 5 characters long\n"));
1492                 else
1493                     break;
1494             }
1495         }
1496         if( !amail ) {
1497             for(;;) {
1498                 m_free(amail);
1499                 amail = cpr_get("keygen.email",_("Email address: "));
1500                 trim_spaces(amail);
1501                 cpr_kill_prompt();
1502                 if( !*amail || opt.allow_freeform_uid )
1503                     break;   /* no email address is okay */
1504                 else if( has_invalid_email_chars(amail)
1505                          || string_count_chr(amail,'@') != 1
1506                          || *amail == '@'
1507                          || amail[strlen(amail)-1] == '@'
1508                          || amail[strlen(amail)-1] == '.'
1509                          || strstr(amail, "..") )
1510                     tty_printf(_("Not a valid email address\n"));
1511                 else
1512                     break;
1513             }
1514         }
1515         if( !acomment ) {
1516             for(;;) {
1517                 m_free(acomment);
1518                 acomment = cpr_get("keygen.comment",_("Comment: "));
1519                 trim_spaces(acomment);
1520                 cpr_kill_prompt();
1521                 if( !*acomment )
1522                     break;   /* no comment is okay */
1523                 else if( strpbrk( acomment, "()" ) )
1524                     tty_printf(_("Invalid character in comment\n"));
1525                 else
1526                     break;
1527             }
1528         }
1529
1530
1531         m_free(uid);
1532         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1533         p = stpcpy(p, aname );
1534         if( *acomment )
1535             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1536         if( *amail )
1537             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1538
1539         /* append a warning if we do not have dev/random
1540          * or it is switched into  quick testmode */
1541         if( quick_random_gen(-1) )
1542             strcpy(p, " (INSECURE!)" );
1543
1544         /* print a note in case that UTF8 mapping has to be done */
1545         for(p=uid; *p; p++ ) {
1546             if( *p & 0x80 ) {
1547                 tty_printf(_("You are using the `%s' character set.\n"),
1548                            get_native_charset() );
1549                 break;
1550             }
1551         }
1552
1553         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1554         /* fixme: add a warning if this user-id already exists */
1555         if( !*amail && !opt.allow_freeform_uid
1556             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1557             fail = 1;
1558             tty_printf(_("Please don't put the email address "
1559                           "into the real name or the comment\n") );
1560         }
1561
1562         for(;;) {
1563             const char *ansstr = _("NnCcEeOoQq");
1564
1565             if( strlen(ansstr) != 10 )
1566                 BUG();
1567             if( cpr_enabled() ) {
1568                 answer = m_strdup(ansstr+6);
1569                 answer[1] = 0;
1570             }
1571             else {
1572                 answer = cpr_get("keygen.userid.cmd", fail?
1573                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1574                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1575                 cpr_kill_prompt();
1576             }
1577             if( strlen(answer) > 1 )
1578                 ;
1579             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1580                 m_free(aname); aname = NULL;
1581                 break;
1582             }
1583             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1584                 m_free(acomment); acomment = NULL;
1585                 break;
1586             }
1587             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1588                 m_free(amail); amail = NULL;
1589                 break;
1590             }
1591             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1592                 if( fail ) {
1593                     tty_printf(_("Please correct the error first\n"));
1594                 }
1595                 else {
1596                     m_free(aname); aname = NULL;
1597                     m_free(acomment); acomment = NULL;
1598                     m_free(amail); amail = NULL;
1599                     break;
1600                 }
1601             }
1602             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1603                 m_free(aname); aname = NULL;
1604                 m_free(acomment); acomment = NULL;
1605                 m_free(amail); amail = NULL;
1606                 m_free(uid); uid = NULL;
1607                 break;
1608             }
1609             m_free(answer);
1610         }
1611         m_free(answer);
1612         if( !amail && !acomment && !amail )
1613             break;
1614         m_free(uid); uid = NULL;
1615     }
1616     if( uid ) {
1617         char *p = native_to_utf8( uid );
1618         m_free( uid );
1619         uid = p;
1620     }
1621     return uid;
1622 }
1623
1624
1625 static DEK *
1626 do_ask_passphrase( STRING2KEY **ret_s2k )
1627 {
1628     DEK *dek = NULL;
1629     STRING2KEY *s2k;
1630     const char *errtext = NULL;
1631
1632     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1633
1634     s2k = m_alloc_secure( sizeof *s2k );
1635     for(;;) {
1636         s2k->mode = opt.s2k_mode;
1637         s2k->hash_algo = opt.s2k_digest_algo;
1638         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1639                                  errtext, NULL);
1640         if( !dek ) {
1641             errtext = N_("passphrase not correctly repeated; try again");
1642             tty_printf(_("%s.\n"), _(errtext));
1643         }
1644         else if( !dek->keylen ) {
1645             m_free(dek); dek = NULL;
1646             m_free(s2k); s2k = NULL;
1647             tty_printf(_(
1648             "You don't want a passphrase - this is probably a *bad* idea!\n"
1649             "I will do it anyway.  You can change your passphrase at any time,\n"
1650             "using this program with the option \"--edit-key\".\n\n"));
1651             break;
1652         }
1653         else
1654             break; /* okay */
1655     }
1656     *ret_s2k = s2k;
1657     return dek;
1658 }
1659
1660
1661 static int
1662 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1663            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
1664            int is_subkey )
1665 {
1666   int rc=0;
1667
1668   if( !opt.batch )
1669     tty_printf(_(
1670 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1671 "some other action (type on the keyboard, move the mouse, utilize the\n"
1672 "disks) during the prime generation; this gives the random number\n"
1673 "generator a better chance to gain enough entropy.\n") );
1674
1675   if( algo == PUBKEY_ALGO_ELGAMAL_E )
1676     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1677                  is_subkey);
1678   else if( algo == PUBKEY_ALGO_DSA )
1679     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1680                  is_subkey);
1681   else if( algo == PUBKEY_ALGO_RSA )
1682     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1683                  is_subkey);
1684   else
1685     BUG();
1686
1687 #ifdef ENABLE_COMMENT_PACKETS
1688   if( !rc ) {
1689     add_kbnode( pub_root,
1690                 make_comment_node("#created by GNUPG v" VERSION " ("
1691                                   PRINTABLE_OS_NAME ")"));
1692     add_kbnode( sec_root,
1693                 make_comment_node("#created by GNUPG v" VERSION " ("
1694                                   PRINTABLE_OS_NAME ")"));
1695   }
1696 #endif
1697   return rc;
1698 }
1699
1700
1701 /****************
1702  * Generate a new user id packet, or return NULL if canceled
1703  */
1704 PKT_user_id *
1705 generate_user_id()
1706 {
1707     PKT_user_id *uid;
1708     char *p;
1709     size_t n;
1710
1711     p = ask_user_id( 1 );
1712     if( !p )
1713         return NULL;
1714     n = strlen(p);
1715     uid = m_alloc_clear( sizeof *uid + n - 1 );
1716     uid->len = n;
1717     strcpy(uid->name, p);
1718     uid->ref = 1;
1719     return uid;
1720 }
1721
1722
1723 static void
1724 release_parameter_list( struct para_data_s *r )
1725 {
1726     struct para_data_s *r2;
1727
1728     for( ; r ; r = r2 ) {
1729         r2 = r->next;
1730         if( r->key == pPASSPHRASE_DEK )
1731             m_free( r->u.dek );
1732         else if( r->key == pPASSPHRASE_S2K )
1733             m_free( r->u.s2k );
1734
1735         m_free(r);
1736     }
1737 }
1738
1739 static struct para_data_s *
1740 get_parameter( struct para_data_s *para, enum para_name key )
1741 {
1742     struct para_data_s *r;
1743
1744     for( r = para; r && r->key != key; r = r->next )
1745         ;
1746     return r;
1747 }
1748
1749 static const char *
1750 get_parameter_value( struct para_data_s *para, enum para_name key )
1751 {
1752     struct para_data_s *r = get_parameter( para, key );
1753     return (r && *r->u.value)? r->u.value : NULL;
1754 }
1755
1756 static int
1757 get_parameter_algo( struct para_data_s *para, enum para_name key )
1758 {
1759     int i;
1760     struct para_data_s *r = get_parameter( para, key );
1761     if( !r )
1762         return -1;
1763     if( digitp( r->u.value ) )
1764         i = atoi( r->u.value );
1765     else
1766         i = string_to_pubkey_algo( r->u.value );
1767     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1768       i = 0; /* we don't want to allow generation of these algorithms */
1769     return i;
1770 }
1771
1772 /* 
1773  * parse the usage parameter and set the keyflags.  Return true on error.
1774  */
1775 static int
1776 parse_parameter_usage (const char *fname,
1777                        struct para_data_s *para, enum para_name key)
1778 {
1779     struct para_data_s *r = get_parameter( para, key );
1780     char *p, *pn;
1781     unsigned int use;
1782
1783     if( !r )
1784         return 0; /* none (this is an optional parameter)*/
1785     
1786     use = 0;
1787     pn = r->u.value;
1788     while ( (p = strsep (&pn, " \t,")) ) {
1789         if ( !*p)
1790             ;
1791         else if ( !ascii_strcasecmp (p, "sign") )
1792             use |= PUBKEY_USAGE_SIG;
1793         else if ( !ascii_strcasecmp (p, "encrypt") )
1794             use |= PUBKEY_USAGE_ENC;
1795         else if ( !ascii_strcasecmp (p, "auth") )
1796             use |= PUBKEY_USAGE_AUTH;
1797         else {
1798             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1799             return -1; /* error */
1800         }
1801     }
1802     r->u.usage = use;
1803     return 0;
1804 }
1805
1806 static int
1807 parse_revocation_key (const char *fname,
1808                       struct para_data_s *para, enum para_name key)
1809 {
1810   struct para_data_s *r = get_parameter( para, key );
1811   struct revocation_key revkey;
1812   char *pn;
1813   int i;
1814
1815   if( !r )
1816     return 0; /* none (this is an optional parameter) */
1817
1818   pn = r->u.value;
1819
1820   revkey.class=0x80;
1821   revkey.algid=atoi(pn);
1822   if(!revkey.algid)
1823     goto fail;
1824
1825   /* Skip to the fpr */
1826   while(*pn && *pn!=':')
1827     pn++;
1828
1829   if(*pn!=':')
1830     goto fail;
1831
1832   pn++;
1833
1834   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1835     {
1836       int c=hextobyte(pn);
1837       if(c==-1)
1838         goto fail;
1839
1840       revkey.fpr[i]=c;
1841     }
1842
1843   /* skip to the tag */
1844   while(*pn && *pn!='s' && *pn!='S')
1845     pn++;
1846
1847   if(ascii_strcasecmp(pn,"sensitive")==0)
1848     revkey.class|=0x40;
1849
1850   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
1851
1852   return 0;
1853
1854   fail:
1855   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
1856   return -1; /* error */
1857 }
1858
1859
1860 static u32
1861 get_parameter_u32( struct para_data_s *para, enum para_name key )
1862 {
1863     struct para_data_s *r = get_parameter( para, key );
1864
1865     if( !r )
1866         return 0;
1867     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1868         return r->u.expire;
1869     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
1870         return r->u.usage;
1871
1872     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1873 }
1874
1875 static unsigned int
1876 get_parameter_uint( struct para_data_s *para, enum para_name key )
1877 {
1878     return get_parameter_u32( para, key );
1879 }
1880
1881 static DEK *
1882 get_parameter_dek( struct para_data_s *para, enum para_name key )
1883 {
1884     struct para_data_s *r = get_parameter( para, key );
1885     return r? r->u.dek : NULL;
1886 }
1887
1888 static STRING2KEY *
1889 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1890 {
1891     struct para_data_s *r = get_parameter( para, key );
1892     return r? r->u.s2k : NULL;
1893 }
1894
1895 static struct revocation_key *
1896 get_parameter_revkey( struct para_data_s *para, enum para_name key )
1897 {
1898     struct para_data_s *r = get_parameter( para, key );
1899     return r? &r->u.revkey : NULL;
1900 }
1901
1902 static int
1903 proc_parameter_file( struct para_data_s *para, const char *fname,
1904                      struct output_control_s *outctrl, int card )
1905 {
1906     struct para_data_s *r;
1907     const char *s1, *s2, *s3;
1908     size_t n;
1909     char *p;
1910     int i;
1911
1912     /* check that we have all required parameters */
1913     assert( get_parameter( para, pKEYTYPE ) );
1914     i = get_parameter_algo( para, pKEYTYPE );
1915     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
1916         r = get_parameter( para, pKEYTYPE );
1917         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1918         return -1;
1919     }
1920
1921     if (parse_parameter_usage (fname, para, pKEYUSAGE))
1922         return -1;
1923
1924     i = get_parameter_algo( para, pSUBKEYTYPE );
1925     if( i > 0 && check_pubkey_algo( i ) ) {
1926         r = get_parameter( para, pSUBKEYTYPE );
1927         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1928         return -1;
1929     }
1930     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
1931         return -1;
1932
1933
1934     if( !get_parameter_value( para, pUSERID ) ) {
1935         /* create the formatted user ID */
1936         s1 = get_parameter_value( para, pNAMEREAL );
1937         s2 = get_parameter_value( para, pNAMECOMMENT );
1938         s3 = get_parameter_value( para, pNAMEEMAIL );
1939         if( s1 || s2 || s3 ) {
1940             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1941             r = m_alloc_clear( sizeof *r + n + 20 );
1942             r->key = pUSERID;
1943             p = r->u.value;
1944             if( s1 )
1945                 p = stpcpy(p, s1 );
1946             if( s2 )
1947                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1948             if( s3 )
1949                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1950             r->next = para;
1951             para = r;
1952         }
1953     }
1954
1955     /* Set preferences, if any. */
1956     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
1957
1958     /* Set revoker, if any. */
1959     if (parse_revocation_key (fname, para, pREVOKER))
1960       return -1;
1961
1962     /* make DEK and S2K from the Passphrase */
1963     r = get_parameter( para, pPASSPHRASE );
1964     if( r && *r->u.value ) {
1965         /* we have a plain text passphrase - create a DEK from it.
1966          * It is a little bit ridiculous to keep it ih secure memory
1967          * but becuase we do this alwasy, why not here */
1968         STRING2KEY *s2k;
1969         DEK *dek;
1970
1971         s2k = m_alloc_secure( sizeof *s2k );
1972         s2k->mode = opt.s2k_mode;
1973         s2k->hash_algo = opt.s2k_digest_algo;
1974         set_next_passphrase( r->u.value );
1975         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
1976                                  NULL, NULL);
1977         set_next_passphrase( NULL );
1978         assert( dek );
1979         memset( r->u.value, 0, strlen(r->u.value) );
1980
1981         r = m_alloc_clear( sizeof *r );
1982         r->key = pPASSPHRASE_S2K;
1983         r->u.s2k = s2k;
1984         r->next = para;
1985         para = r;
1986         r = m_alloc_clear( sizeof *r );
1987         r->key = pPASSPHRASE_DEK;
1988         r->u.dek = dek;
1989         r->next = para;
1990         para = r;
1991     }
1992
1993     /* make KEYEXPIRE from Expire-Date */
1994     r = get_parameter( para, pEXPIREDATE );
1995     if( r && *r->u.value ) {
1996         i = parse_expire_string( r->u.value );
1997         if( i < 0 ) {
1998             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1999             return -1;
2000         }
2001         r->u.expire = i * 86400L;
2002         r->key = pKEYEXPIRE;  /* change hat entry */
2003         /* also set it for the subkey */
2004         r = m_alloc_clear( sizeof *r + 20 );
2005         r->key = pSUBKEYEXPIRE;
2006         r->u.expire = i * 86400L;
2007         r->next = para;
2008         para = r;
2009     }
2010
2011     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2012         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2013         return -1;
2014     }
2015
2016     do_generate_keypair( para, outctrl, card );
2017     return 0;
2018 }
2019
2020
2021 /****************
2022  * Kludge to allow non interactive key generation controlled
2023  * by a parameter file (which currently is only stdin)
2024  * Note, that string parameters are expected to be in UTF-8
2025  */
2026 static void
2027 read_parameter_file( const char *fname )
2028 {
2029     static struct { const char *name;
2030                     enum para_name key;
2031     } keywords[] = {
2032         { "Key-Type",       pKEYTYPE},
2033         { "Key-Length",     pKEYLENGTH },
2034         { "Key-Usage",      pKEYUSAGE },
2035         { "Subkey-Type",    pSUBKEYTYPE },
2036         { "Subkey-Length",  pSUBKEYLENGTH },
2037         { "Subkey-Usage",   pSUBKEYUSAGE },
2038         { "Name-Real",      pNAMEREAL },
2039         { "Name-Email",     pNAMEEMAIL },
2040         { "Name-Comment",   pNAMECOMMENT },
2041         { "Expire-Date",    pEXPIREDATE },
2042         { "Passphrase",     pPASSPHRASE },
2043         { "Preferences",    pPREFERENCES },
2044         { "Revoker",        pREVOKER },
2045         { NULL, 0 }
2046     };
2047     FILE *fp;
2048     char line[1024], *p;
2049     int lnr;
2050     const char *err = NULL;
2051     struct para_data_s *para, *r;
2052     int i;
2053     struct output_control_s outctrl;
2054
2055     memset( &outctrl, 0, sizeof( outctrl ) );
2056
2057     if( !fname || !*fname || !strcmp(fname,"-") ) {
2058         fp = stdin;
2059         fname = "-";
2060     }
2061     else {
2062         fp = fopen( fname, "r" );
2063         if( !fp ) {
2064             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
2065             return;
2066         }
2067     }
2068
2069     lnr = 0;
2070     err = NULL;
2071     para = NULL;
2072     while( fgets( line, DIM(line)-1, fp ) ) {
2073         char *keyword, *value;
2074
2075         lnr++;
2076         if( *line && line[strlen(line)-1] != '\n' ) {
2077             err = "line too long";
2078             break;
2079         }
2080         for( p = line; isspace(*(byte*)p); p++ )
2081             ;
2082         if( !*p || *p == '#' )
2083             continue;
2084         keyword = p;
2085         if( *keyword == '%' ) {
2086             for( ; !isspace(*(byte*)p); p++ )
2087                 ;
2088             if( *p )
2089                 *p++ = 0;
2090             for( ; isspace(*(byte*)p); p++ )
2091                 ;
2092             value = p;
2093             trim_trailing_ws( value, strlen(value) );
2094             if( !ascii_strcasecmp( keyword, "%echo" ) )
2095                 log_info("%s\n", value );
2096             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2097                 outctrl.dryrun = 1;
2098             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2099                 outctrl.lnr = lnr;
2100                 proc_parameter_file( para, fname, &outctrl, 0 );
2101                 release_parameter_list( para );
2102                 para = NULL;
2103             }
2104             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2105                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2106                     ; /* still the same file - ignore it */
2107                 else {
2108                     m_free( outctrl.pub.newfname );
2109                     outctrl.pub.newfname = m_strdup( value );
2110                     outctrl.use_files = 1;
2111                 }
2112             }
2113             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2114                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2115                     ; /* still the same file - ignore it */
2116                 else {
2117                    m_free( outctrl.sec.newfname );
2118                    outctrl.sec.newfname = m_strdup( value );
2119                    outctrl.use_files = 1;
2120                 }
2121             }
2122             else
2123                 log_info("skipping control `%s' (%s)\n", keyword, value );
2124
2125
2126             continue;
2127         }
2128
2129
2130         if( !(p = strchr( p, ':' )) || p == keyword ) {
2131             err = "missing colon";
2132             break;
2133         }
2134         if( *p )
2135             *p++ = 0;
2136         for( ; isspace(*(byte*)p); p++ )
2137             ;
2138         if( !*p ) {
2139             err = "missing argument";
2140             break;
2141         }
2142         value = p;
2143         trim_trailing_ws( value, strlen(value) );
2144
2145         for(i=0; keywords[i].name; i++ ) {
2146             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2147                 break;
2148         }
2149         if( !keywords[i].name ) {
2150             err = "unknown keyword";
2151             break;
2152         }
2153         if( keywords[i].key != pKEYTYPE && !para ) {
2154             err = "parameter block does not start with \"Key-Type\"";
2155             break;
2156         }
2157
2158         if( keywords[i].key == pKEYTYPE && para ) {
2159             outctrl.lnr = lnr;
2160             proc_parameter_file( para, fname, &outctrl, 0 );
2161             release_parameter_list( para );
2162             para = NULL;
2163         }
2164         else {
2165             for( r = para; r; r = r->next ) {
2166                 if( r->key == keywords[i].key )
2167                     break;
2168             }
2169             if( r ) {
2170                 err = "duplicate keyword";
2171                 break;
2172             }
2173         }
2174         r = m_alloc_clear( sizeof *r + strlen( value ) );
2175         r->lnr = lnr;
2176         r->key = keywords[i].key;
2177         strcpy( r->u.value, value );
2178         r->next = para;
2179         para = r;
2180     }
2181     if( err )
2182         log_error("%s:%d: %s\n", fname, lnr, err );
2183     else if( ferror(fp) ) {
2184         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
2185     }
2186     else if( para ) {
2187         outctrl.lnr = lnr;
2188         proc_parameter_file( para, fname, &outctrl, 0 );
2189     }
2190
2191     if( outctrl.use_files ) { /* close open streams */
2192         iobuf_close( outctrl.pub.stream );
2193         iobuf_close( outctrl.sec.stream );
2194
2195         /* Must invalidate that ugly cache to actually close it.  */
2196         if (outctrl.pub.fname)
2197           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2198         if (outctrl.sec.fname)
2199           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2200
2201         m_free( outctrl.pub.fname );
2202         m_free( outctrl.pub.newfname );
2203         m_free( outctrl.sec.fname );
2204         m_free( outctrl.sec.newfname );
2205     }
2206
2207     release_parameter_list( para );
2208     if( strcmp( fname, "-" ) )
2209         fclose(fp);
2210 }
2211
2212
2213 /*
2214  * Generate a keypair (fname is only used in batch mode) If
2215  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2216  * OpenPGP Card.
2217  */
2218 void
2219 generate_keypair( const char *fname, const char *card_serialno )
2220 {
2221   unsigned int nbits;
2222   char *uid = NULL;
2223   DEK *dek;
2224   STRING2KEY *s2k;
2225   int algo;
2226   unsigned int use;
2227   int both = 0;
2228   u32 expire;
2229   struct para_data_s *para = NULL;
2230   struct para_data_s *r;
2231   struct output_control_s outctrl;
2232   
2233   memset( &outctrl, 0, sizeof( outctrl ) );
2234   
2235   if (opt.batch && card_serialno)
2236     {
2237       /* We don't yet support unattended key generation. */
2238       log_error (_("sorry, can't do this in batch mode\n"));
2239       return;
2240     }
2241   
2242    if (opt.batch)
2243      {
2244        read_parameter_file( fname );
2245        return;
2246      }
2247
2248    if (card_serialno)
2249      {
2250 #ifdef ENABLE_CARD_SUPPORT
2251        r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2252        r->key = pSERIALNO;
2253        strcpy( r->u.value, card_serialno);
2254        r->next = para;
2255        para = r;
2256        
2257        algo = PUBKEY_ALGO_RSA;
2258        
2259        r = xcalloc (1, sizeof *r + 20 );
2260        r->key = pKEYTYPE;
2261        sprintf( r->u.value, "%d", algo );
2262        r->next = para;
2263        para = r;
2264        r = xcalloc (1, sizeof *r + 20 );
2265        r->key = pKEYUSAGE;
2266        strcpy (r->u.value, "sign");
2267        r->next = para;
2268        para = r;
2269        
2270        r = xcalloc (1, sizeof *r + 20 );
2271        r->key = pSUBKEYTYPE;
2272        sprintf( r->u.value, "%d", algo );
2273        r->next = para;
2274        para = r;
2275        r = xcalloc (1, sizeof *r + 20 );
2276        r->key = pSUBKEYUSAGE;
2277        strcpy (r->u.value, "encrypt");
2278        r->next = para;
2279        para = r;
2280        
2281        r = xcalloc (1, sizeof *r + 20 );
2282        r->key = pAUTHKEYTYPE;
2283        sprintf( r->u.value, "%d", algo );
2284        r->next = para;
2285        para = r;
2286 #endif /*ENABLE_CARD_SUPPORT*/
2287      }
2288    else
2289      {
2290        algo = ask_algo( 0, &use );
2291        if( !algo )
2292          { /* default: DSA with ElG subkey of the specified size */
2293            both = 1;
2294            r = m_alloc_clear( sizeof *r + 20 );
2295            r->key = pKEYTYPE;
2296            sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2297            r->next = para;
2298            para = r;
2299            tty_printf(_("DSA keypair will have 1024 bits.\n"));
2300            r = m_alloc_clear( sizeof *r + 20 );
2301            r->key = pKEYLENGTH;
2302            strcpy( r->u.value, "1024" );
2303            r->next = para;
2304            para = r;
2305            r = m_alloc_clear( sizeof *r + 20 );
2306            r->key = pKEYUSAGE;
2307            strcpy( r->u.value, "sign" );
2308            r->next = para;
2309            para = r;
2310            
2311            algo = PUBKEY_ALGO_ELGAMAL_E;
2312            r = m_alloc_clear( sizeof *r + 20 );
2313            r->key = pSUBKEYTYPE;
2314            sprintf( r->u.value, "%d", algo );
2315            r->next = para;
2316            para = r;
2317            r = m_alloc_clear( sizeof *r + 20 );
2318            r->key = pSUBKEYUSAGE;
2319            strcpy( r->u.value, "encrypt" );
2320            r->next = para;
2321            para = r;
2322          }
2323        else 
2324          {
2325            r = m_alloc_clear( sizeof *r + 20 );
2326            r->key = pKEYTYPE;
2327            sprintf( r->u.value, "%d", algo );
2328            r->next = para;
2329            para = r;
2330            
2331            if (use)
2332              {
2333                r = m_alloc_clear( sizeof *r + 20 );
2334                r->key = pKEYUSAGE;
2335                sprintf( r->u.value, "%s%s",
2336                         (use & PUBKEY_USAGE_SIG)? "sign ":"",
2337                         (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
2338                r->next = para;
2339                para = r;
2340              }
2341            
2342          }
2343        
2344        nbits = ask_keysize( algo );
2345        r = m_alloc_clear( sizeof *r + 20 );
2346        r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2347        sprintf( r->u.value, "%u", nbits);
2348        r->next = para;
2349        para = r;
2350      }
2351
2352    expire = ask_expire_interval(0);
2353     r = m_alloc_clear( sizeof *r + 20 );
2354     r->key = pKEYEXPIRE;
2355     r->u.expire = expire;
2356     r->next = para;
2357     para = r;
2358     r = m_alloc_clear( sizeof *r + 20 );
2359     r->key = pSUBKEYEXPIRE;
2360     r->u.expire = expire;
2361     r->next = para;
2362     para = r;
2363
2364     uid = ask_user_id(0);
2365     if( !uid ) 
2366       {
2367         log_error(_("Key generation canceled.\n"));
2368         release_parameter_list( para );
2369         return;
2370       }
2371     r = m_alloc_clear( sizeof *r + strlen(uid) );
2372     r->key = pUSERID;
2373     strcpy( r->u.value, uid );
2374     r->next = para;
2375     para = r;
2376     
2377     dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2378     if( dek )
2379       {
2380         r = m_alloc_clear( sizeof *r );
2381         r->key = pPASSPHRASE_DEK;
2382         r->u.dek = dek;
2383         r->next = para;
2384         para = r;
2385         r = m_alloc_clear( sizeof *r );
2386         r->key = pPASSPHRASE_S2K;
2387         r->u.s2k = s2k;
2388         r->next = para;
2389         para = r;
2390       }
2391     
2392     proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2393     release_parameter_list( para );
2394 }
2395
2396
2397 static void
2398 print_status_key_created (int letter, PKT_public_key *pk)
2399 {
2400   byte array[MAX_FINGERPRINT_LEN], *s;
2401   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
2402   size_t i, n;
2403   
2404   p = buf;
2405   *p++ = letter;
2406   *p++ = ' ';
2407   fingerprint_from_pk (pk, array, &n);
2408   s = array;
2409   for (i=0; i < n ; i++, s++, p += 2)
2410     sprintf (p, "%02X", *s);
2411   *p = 0;
2412   write_status_text (STATUS_KEY_CREATED, buf);
2413 }
2414
2415 static void
2416 do_generate_keypair( struct para_data_s *para,
2417                      struct output_control_s *outctrl, int card )
2418 {
2419     KBNODE pub_root = NULL;
2420     KBNODE sec_root = NULL;
2421     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2422     const char *s;
2423     struct revocation_key *revkey;
2424     int rc;
2425     int did_sub = 0;
2426
2427     if( outctrl->dryrun ) {
2428         log_info("dry-run mode - key generation skipped\n");
2429         return;
2430     }
2431
2432
2433     if( outctrl->use_files ) {
2434         if( outctrl->pub.newfname ) {
2435             iobuf_close(outctrl->pub.stream);
2436             outctrl->pub.stream = NULL;
2437             if (outctrl->pub.fname)
2438               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
2439             m_free( outctrl->pub.fname );
2440             outctrl->pub.fname =  outctrl->pub.newfname;
2441             outctrl->pub.newfname = NULL;
2442
2443             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2444             if( !outctrl->pub.stream ) {
2445                 log_error("can't create `%s': %s\n", outctrl->pub.newfname,
2446                                                      strerror(errno) );
2447                 return;
2448             }
2449             if( opt.armor ) {
2450                 outctrl->pub.afx.what = 1;
2451                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2452                                                     &outctrl->pub.afx );
2453             }
2454         }
2455         if( outctrl->sec.newfname ) {
2456             mode_t oldmask;
2457
2458             iobuf_close(outctrl->sec.stream);
2459             outctrl->sec.stream = NULL;
2460             if (outctrl->sec.fname)
2461               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
2462             m_free( outctrl->sec.fname );
2463             outctrl->sec.fname =  outctrl->sec.newfname;
2464             outctrl->sec.newfname = NULL;
2465
2466             oldmask = umask (077);
2467             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2468             umask (oldmask);
2469             if( !outctrl->sec.stream ) {
2470                 log_error("can't create `%s': %s\n", outctrl->sec.newfname,
2471                                                      strerror(errno) );
2472                 return;
2473             }
2474             if( opt.armor ) {
2475                 outctrl->sec.afx.what = 5;
2476                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2477                                                     &outctrl->sec.afx );
2478             }
2479         }
2480         assert( outctrl->pub.stream );
2481         assert( outctrl->sec.stream );
2482         if( opt.verbose ) {
2483             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2484             if (card)
2485               log_info (_("writing secret key stub to `%s'\n"),
2486                         outctrl->sec.fname);
2487             else
2488               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2489         }
2490     }
2491
2492
2493     /* we create the packets as a tree of kbnodes. Because the structure
2494      * we create is known in advance we simply generate a linked list
2495      * The first packet is a dummy comment packet which we flag
2496      * as deleted.  The very first packet must always be a KEY packet.
2497      */
2498     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
2499     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
2500
2501     if (!card)
2502       {
2503         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2504                         get_parameter_uint( para, pKEYLENGTH ),
2505                         pub_root, sec_root,
2506                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2507                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2508                         &pri_sk,
2509                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
2510       }
2511     else
2512       {
2513         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root,
2514                            get_parameter_u32 (para, pKEYEXPIRE), para);
2515         if (!rc)
2516           {
2517             pri_sk = sec_root->next->pkt->pkt.secret_key;
2518             assert (pri_sk);
2519           }
2520       }
2521
2522     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2523       {
2524         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
2525         if(!rc)
2526           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
2527       }
2528
2529     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
2530         write_uid(pub_root, s );
2531         if( !rc )
2532             write_uid(sec_root, s );
2533         if( !rc )
2534             rc = write_selfsig(pub_root, pub_root, pri_sk,
2535                                get_parameter_uint (para, pKEYUSAGE));
2536         if( !rc )
2537             rc = write_selfsig(sec_root, pub_root, pri_sk,
2538                                get_parameter_uint (para, pKEYUSAGE));
2539     }
2540
2541     if( get_parameter( para, pSUBKEYTYPE ) )
2542       {
2543         if (!card)
2544           {
2545             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2546                             get_parameter_uint( para, pSUBKEYLENGTH ),
2547                             pub_root, sec_root,
2548                             get_parameter_dek( para, pPASSPHRASE_DEK ),
2549                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
2550                             &sub_sk,
2551                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
2552           }
2553         else
2554           {
2555             rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
2556                                get_parameter_u32 (para, pKEYEXPIRE), para);
2557           }
2558
2559         if( !rc )
2560           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
2561                                 get_parameter_uint (para, pSUBKEYUSAGE));
2562         if( !rc )
2563           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
2564                                 get_parameter_uint (para, pSUBKEYUSAGE));
2565         did_sub = 1;
2566       }
2567
2568     if (card && get_parameter (para, pAUTHKEYTYPE))
2569       {
2570         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root,
2571                            get_parameter_u32 (para, pKEYEXPIRE), para);
2572         
2573         if (!rc)
2574           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2575         if (!rc)
2576           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2577       }
2578     
2579     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2580         rc = write_keyblock( outctrl->pub.stream, pub_root );
2581         if( rc )
2582             log_error("can't write public key: %s\n", g10_errstr(rc) );
2583         if( !rc ) {
2584             rc = write_keyblock( outctrl->sec.stream, sec_root );
2585             if( rc )
2586                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2587         }
2588
2589     }
2590     else if( !rc ) { /* write to the standard keyrings */
2591         KEYDB_HANDLE pub_hd = keydb_new (0);
2592         KEYDB_HANDLE sec_hd = keydb_new (1);
2593
2594         /* FIXME: we may have to create the keyring first */
2595         rc = keydb_locate_writable (pub_hd, NULL);
2596         if (rc) 
2597             log_error (_("no writable public keyring found: %s\n"),
2598                        g10_errstr (rc));
2599
2600         if (!rc) {  
2601             rc = keydb_locate_writable (sec_hd, NULL);
2602             if (rc) 
2603                 log_error (_("no writable secret keyring found: %s\n"),
2604                            g10_errstr (rc));
2605         }
2606
2607         if (!rc && opt.verbose) {
2608             log_info(_("writing public key to `%s'\n"),
2609                      keydb_get_resource_name (pub_hd));
2610             if (card)
2611               log_info (_("writing secret key stub to `%s'\n"),
2612                         keydb_get_resource_name (sec_hd));
2613             else
2614               log_info(_("writing secret key to `%s'\n"),
2615                        keydb_get_resource_name (sec_hd));
2616         }
2617
2618         if (!rc) {
2619             rc = keydb_insert_keyblock (pub_hd, pub_root);
2620             if (rc)
2621                 log_error (_("error writing public keyring `%s': %s\n"),
2622                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2623         }
2624
2625         if (!rc) {
2626             rc = keydb_insert_keyblock (sec_hd, sec_root);
2627             if (rc)
2628                 log_error (_("error writing secret keyring `%s': %s\n"),
2629                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2630         }
2631
2632         keydb_release (pub_hd);
2633         keydb_release (sec_hd);
2634
2635         if (!rc) {
2636             int no_enc_rsa =
2637                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2638                 && get_parameter_uint( para, pKEYUSAGE )
2639                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2640             PKT_public_key *pk = find_kbnode (pub_root, 
2641                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2642
2643             keyid_from_pk(pk,pk->main_keyid);
2644             register_trusted_keyid(pk->main_keyid);
2645
2646             update_ownertrust (pk,
2647                                ((get_ownertrust (pk) & ~TRUST_MASK)
2648                                 | TRUST_ULTIMATE ));
2649
2650             if (!opt.batch) {
2651                 tty_printf(_("public and secret key created and signed.\n") );
2652                 tty_printf("\n");
2653                 list_keyblock(pub_root,0,1,NULL);
2654             }
2655             
2656
2657             if( !opt.batch
2658                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2659                      || no_enc_rsa )
2660                 && !get_parameter( para, pSUBKEYTYPE ) )
2661             {
2662                 tty_printf(_("Note that this key cannot be used for "
2663                              "encryption.  You may want to use\n"
2664                              "the command \"--edit-key\" to generate a "
2665                              "secondary key for this purpose.\n") );
2666             }
2667         }
2668     }
2669
2670     if( rc ) {
2671         if( opt.batch )
2672             log_error("key generation failed: %s\n", g10_errstr(rc) );
2673         else
2674             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2675     }
2676     else {
2677         PKT_public_key *pk = find_kbnode (pub_root, 
2678                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2679         print_status_key_created (did_sub? 'B':'P', pk);
2680     }
2681     release_kbnode( pub_root );
2682     release_kbnode( sec_root );
2683
2684     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
2685       free_secret_key(pri_sk); /* shallow copy in card mode. */
2686     if( sub_sk )
2687         free_secret_key(sub_sk);
2688 }
2689
2690
2691 /****************
2692  * add a new subkey to an existing key.
2693  * Returns true if a new key has been generated and put into the keyblocks.
2694  */
2695 int
2696 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2697 {
2698     int okay=0, rc=0;
2699     KBNODE node;
2700     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2701     int algo;
2702     unsigned int use;
2703     u32 expire;
2704     unsigned nbits;
2705     char *passphrase = NULL;
2706     DEK *dek = NULL;
2707     STRING2KEY *s2k = NULL;
2708     u32 cur_time;
2709
2710     /* break out the primary secret key */
2711     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2712     if( !node ) {
2713         log_error("Oops; secret key not found anymore!\n");
2714         goto leave;
2715     }
2716
2717     /* make a copy of the sk to keep the protected one in the keyblock */
2718     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
2719
2720     cur_time = make_timestamp();
2721     if( pri_sk->timestamp > cur_time ) {
2722         ulong d = pri_sk->timestamp - cur_time;
2723         log_info( d==1 ? _("key has been created %lu second "
2724                            "in future (time warp or clock problem)\n")
2725                        : _("key has been created %lu seconds "
2726                            "in future (time warp or clock problem)\n"), d );
2727         if( !opt.ignore_time_conflict ) {
2728             rc = G10ERR_TIME_CONFLICT;
2729             goto leave;
2730         }
2731     }
2732
2733     if (pri_sk->version < 4) {
2734         log_info (_("NOTE: creating subkeys for v3 keys "
2735                     "is not OpenPGP compliant\n"));
2736         goto leave;
2737     }
2738
2739     /* unprotect to get the passphrase */
2740     switch( is_secret_key_protected( pri_sk ) ) {
2741       case -1:
2742         rc = G10ERR_PUBKEY_ALGO;
2743         break;
2744       case 0:
2745         tty_printf("This key is not protected.\n");
2746         break;
2747       default:
2748         tty_printf("Key is protected.\n");
2749         rc = check_secret_key( pri_sk, 0 );
2750         if( !rc )
2751             passphrase = get_last_passphrase();
2752         break;
2753     }
2754     if( rc )
2755         goto leave;
2756
2757     algo = ask_algo( 1, &use );
2758     assert(algo);
2759     nbits = ask_keysize( algo );
2760     expire = ask_expire_interval(0);
2761     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
2762                                                   _("Really create? ") ) )
2763         goto leave;
2764
2765     if( passphrase ) {
2766         s2k = m_alloc_secure( sizeof *s2k );
2767         s2k->mode = opt.s2k_mode;
2768         s2k->hash_algo = opt.s2k_digest_algo;
2769         set_next_passphrase( passphrase );
2770         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2771                                  NULL, NULL );
2772     }
2773
2774     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
2775                                       dek, s2k, &sub_sk, expire, 1 );
2776     if( !rc )
2777         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
2778     if( !rc )
2779         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
2780     if( !rc ) {
2781         okay = 1;
2782         write_status_text (STATUS_KEY_CREATED, "S");
2783     }
2784
2785   leave:
2786     if( rc )
2787         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
2788     m_free( passphrase );
2789     m_free( dek );
2790     m_free( s2k );
2791     /* release the copy of the (now unprotected) secret keys */
2792     if( pri_sk )
2793         free_secret_key(pri_sk);
2794     if( sub_sk )
2795         free_secret_key(sub_sk);
2796     set_next_passphrase( NULL );
2797     return okay;
2798 }
2799
2800
2801 #ifdef ENABLE_CARD_SUPPORT
2802 /* Generate a subkey on a card. */
2803 int
2804 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
2805                           int keyno, const char *serialno)
2806 {
2807   int okay=0, rc=0;
2808   KBNODE node;
2809   PKT_secret_key *pri_sk = NULL;
2810   int algo;
2811   unsigned int use;
2812   u32 expire;
2813   char *passphrase = NULL;
2814   u32 cur_time;
2815   struct para_data_s *para = NULL;
2816
2817   assert (keyno >= 1 && keyno <= 3);
2818
2819   para = xcalloc (1, sizeof *para + strlen (serialno) );
2820   para->key = pSERIALNO;
2821   strcpy (para->u.value, serialno);
2822
2823   /* Break out the primary secret key */
2824   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2825   if(!node)
2826     {
2827       log_error("Oops; secret key not found anymore!\n");
2828       goto leave;
2829     }
2830
2831   /* Make a copy of the sk to keep the protected one in the keyblock */
2832   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
2833
2834   cur_time = make_timestamp();
2835   if (pri_sk->timestamp > cur_time)
2836     {
2837       ulong d = pri_sk->timestamp - cur_time;
2838       log_info (d==1 ? _("key has been created %lu second "
2839                          "in future (time warp or clock problem)\n")
2840                      : _("key has been created %lu seconds "
2841                          "in future (time warp or clock problem)\n"), d );
2842         if (!opt.ignore_time_conflict)
2843           {
2844             rc = G10ERR_TIME_CONFLICT;
2845             goto leave;
2846           }
2847     }
2848
2849   if (pri_sk->version < 4)
2850     {
2851       log_info (_("NOTE: creating subkeys for v3 keys "
2852                   "is not OpenPGP compliant\n"));
2853       goto leave;
2854     }
2855
2856   /* Unprotect to get the passphrase. */
2857   switch( is_secret_key_protected (pri_sk) )
2858     {
2859     case -1:
2860       rc = G10ERR_PUBKEY_ALGO;
2861       break;
2862     case 0:
2863       tty_printf("This key is not protected.\n");
2864       break;
2865     default:
2866       tty_printf("Key is protected.\n");
2867       rc = check_secret_key( pri_sk, 0 );
2868       if (!rc)
2869         passphrase = get_last_passphrase();
2870       break;
2871     }
2872   if (rc)
2873     goto leave;
2874
2875   algo = PUBKEY_ALGO_RSA;
2876   expire = ask_expire_interval (0);
2877   if (keyno == 1)
2878     use = PUBKEY_USAGE_SIG;
2879   else if (keyno == 2)
2880     use = PUBKEY_USAGE_ENC;
2881   else
2882     use = PUBKEY_USAGE_AUTH;
2883   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
2884                                                _("Really create? ") ) )
2885     goto leave;
2886
2887   if (passphrase)
2888     set_next_passphrase (passphrase);
2889   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock, expire, para);
2890   if (!rc)
2891     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, NULL, use);
2892   if (!rc)
2893     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, NULL, use);
2894   if (!rc)
2895     {
2896       okay = 1;
2897       write_status_text (STATUS_KEY_CREATED, "S");
2898     }
2899
2900  leave:
2901   if (rc)
2902     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
2903   m_free (passphrase);
2904   /* Release the copy of the (now unprotected) secret keys. */
2905   if (pri_sk)
2906     free_secret_key (pri_sk);
2907   set_next_passphrase( NULL );
2908   release_parameter_list (para);
2909   return okay;
2910 }
2911 #endif /* !ENABLE_CARD_SUPPORT */
2912
2913
2914 /****************
2915  * Write a keyblock to an output stream
2916  */
2917 static int
2918 write_keyblock( IOBUF out, KBNODE node )
2919 {
2920     for( ; node ; node = node->next ) {
2921         int rc = build_packet( out, node->pkt );
2922         if( rc ) {
2923             log_error("build_packet(%d) failed: %s\n",
2924                         node->pkt->pkttype, g10_errstr(rc) );
2925             return G10ERR_WRITE_FILE;
2926         }
2927     }
2928     return 0;
2929 }
2930
2931
2932 static int
2933 gen_card_key (int algo, int keyno, int is_primary,
2934               KBNODE pub_root, KBNODE sec_root,
2935               u32 expireval, struct para_data_s *para)
2936 {
2937 #ifdef ENABLE_CARD_SUPPORT
2938   int rc;
2939   const char *s;
2940   struct agent_card_genkey_s info;
2941   PACKET *pkt;
2942   PKT_secret_key *sk;
2943   PKT_public_key *pk;
2944
2945   assert (algo == PUBKEY_ALGO_RSA);
2946
2947   rc = agent_scd_genkey (&info, keyno, 1);
2948 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
2949 /*      { */
2950 /*        tty_printf ("\n"); */
2951 /*        log_error ("WARNING: key does already exists!\n"); */
2952 /*        tty_printf ("\n"); */
2953 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
2954 /*                                    _("Replace existing key? "))) */
2955 /*          rc = agent_scd_genkey (&info, keyno, 1); */
2956 /*      } */
2957
2958   if (rc)
2959     {
2960       log_error ("key generation failed: %s\n", gpg_strerror (rc));
2961       return rc;
2962     }
2963   if ( !info.n || !info.e )
2964     {
2965       log_error ("communication error with SCD\n");
2966       mpi_free (info.n);
2967       mpi_free (info.e);
2968       return gpg_error (GPG_ERR_GENERAL);
2969     }
2970   
2971
2972   pk = xcalloc (1, sizeof *pk );
2973   sk = xcalloc (1, sizeof *sk );
2974   sk->timestamp = pk->timestamp = info.created_at;
2975   sk->version = pk->version = 4;
2976   if (expireval)
2977       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
2978   sk->pubkey_algo = pk->pubkey_algo = algo;
2979   pk->pkey[0] = info.n;
2980   pk->pkey[1] = info.e; 
2981   sk->skey[0] = mpi_copy (pk->pkey[0]);
2982   sk->skey[1] = mpi_copy (pk->pkey[1]);
2983   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
2984   sk->is_protected = 1;
2985   sk->protect.s2k.mode = 1002;
2986   s = get_parameter_value (para, pSERIALNO);
2987   if (s)
2988     {
2989       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2990            sk->protect.ivlen++, s += 2)
2991         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2992     }
2993
2994   pkt = xcalloc (1,sizeof *pkt);
2995   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
2996   pkt->pkt.public_key = pk;
2997   add_kbnode(pub_root, new_kbnode( pkt ));
2998
2999   pkt = xcalloc (1,sizeof *pkt);
3000   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3001   pkt->pkt.secret_key = sk;
3002   add_kbnode(sec_root, new_kbnode( pkt ));
3003
3004   return 0;
3005 #else
3006   return -1;
3007 #endif /*!ENABLE_CARD_SUPPORT*/
3008 }