* gpg.sgml: Document -K.
[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
1181     for(;;) {
1182         answer = cpr_get("keygen.algo",_("Your selection? "));
1183         cpr_kill_prompt();
1184         algo = *answer? atoi(answer): 1;
1185         m_free(answer);
1186         if( algo == 1 && !addmode ) {
1187             algo = 0;   /* create both keys */
1188             break;
1189         }
1190         else if( algo == 6 && opt.expert ) {
1191             algo = PUBKEY_ALGO_RSA;
1192             *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
1193             break;
1194         }
1195         else if( algo == 5 && addmode ) {
1196             algo = PUBKEY_ALGO_RSA;
1197             *r_usage = PUBKEY_USAGE_ENC;
1198             break;
1199         }
1200         else if( algo == 4 ) {
1201             algo = PUBKEY_ALGO_RSA;
1202             *r_usage = PUBKEY_USAGE_SIG;
1203             break;
1204         }
1205         else if( algo == 3 && addmode ) {
1206             algo = PUBKEY_ALGO_ELGAMAL_E;
1207             *r_usage = PUBKEY_USAGE_ENC;
1208             break;
1209         }
1210         else if( algo == 2 ) {
1211             algo = PUBKEY_ALGO_DSA;
1212             *r_usage = PUBKEY_USAGE_SIG;
1213             break;
1214         }
1215         else
1216             tty_printf(_("Invalid selection.\n"));
1217     }
1218     return algo;
1219 }
1220
1221
1222 static unsigned
1223 ask_keysize( int algo )
1224 {
1225     char *answer;
1226     unsigned nbits;
1227
1228     if (algo != PUBKEY_ALGO_DSA && algo != PUBKEY_ALGO_RSA) {
1229         tty_printf (_("About to generate a new %s keypair.\n"
1230                       "              minimum keysize is  768 bits\n"
1231                       "              default keysize is 1024 bits\n"
1232                       "    highest suggested keysize is 2048 bits\n"),
1233                     pubkey_algo_to_string(algo) );
1234     }
1235
1236     for(;;) {
1237         answer = cpr_get("keygen.size",
1238                           _("What keysize do you want? (1024) "));
1239         cpr_kill_prompt();
1240         nbits = *answer? atoi(answer): 1024;
1241         m_free(answer);
1242         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
1243             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
1244         else if( algo == PUBKEY_ALGO_RSA && nbits < 1024 )
1245             tty_printf(_("keysize too small;"
1246                          " 1024 is smallest value allowed for RSA.\n"));
1247         else if( nbits < 768 )
1248             tty_printf(_("keysize too small;"
1249                          " 768 is smallest value allowed.\n"));
1250         else if( nbits > 4096 ) {
1251             /* It is ridiculous and an annoyance to use larger key sizes!
1252              * GnuPG can handle much larger sizes; but it takes an eternity
1253              * to create such a key (but less than the time the Sirius
1254              * Computer Corporation needs to process one of the usual
1255              * complaints) and {de,en}cryption although needs some time.
1256              * So, before you complain about this limitation, I suggest that
1257              * you start a discussion with Marvin about this theme and then
1258              * do whatever you want. */
1259             tty_printf(_("keysize too large; %d is largest value allowed.\n"),
1260                                                                          4096);
1261         }
1262         else if( nbits > 2048 && !cpr_enabled() ) {
1263             tty_printf(
1264                 _("Keysizes larger than 2048 are not suggested because\n"
1265                   "computations take REALLY long!\n"));
1266             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
1267                         "Are you sure that you want this keysize? ")) ) {
1268                 tty_printf(_("Okay, but keep in mind that your monitor "
1269                              "and keyboard radiation is also very vulnerable "
1270                              "to attacks!\n"));
1271                 break;
1272             }
1273         }
1274         else
1275             break;
1276     }
1277     tty_printf(_("Requested keysize is %u bits\n"), nbits );
1278     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
1279         nbits = ((nbits + 63) / 64) * 64;
1280         tty_printf(_("rounded up to %u bits\n"), nbits );
1281     }
1282     else if( (nbits % 32) ) {
1283         nbits = ((nbits + 31) / 32) * 32;
1284         tty_printf(_("rounded up to %u bits\n"), nbits );
1285     }
1286     return nbits;
1287 }
1288
1289
1290 /****************
1291  * Parse an expire string and return it's value in days.
1292  * Returns -1 on error.
1293  */
1294 static int
1295 parse_expire_string( const char *string )
1296 {
1297     int mult;
1298     u32 abs_date=0;
1299     u32 curtime = make_timestamp();
1300     int valid_days;
1301
1302     if( !*string )
1303         valid_days = 0;
1304     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
1305         /* This calculation is not perfectly okay because we
1306          * are later going to simply multiply by 86400 and don't
1307          * correct for leapseconds.  A solution would be to change
1308          * the whole implemenation to work with dates and not intervals
1309          * which are required for v3 keys.
1310          */
1311         valid_days = abs_date/86400-curtime/86400+1;
1312     }
1313     else if( (mult=check_valid_days(string)) ) {
1314         valid_days = atoi(string) * mult;
1315         if( valid_days < 0 || valid_days > 39447 )
1316             valid_days = 0;
1317     }
1318     else {
1319         valid_days = -1;
1320     }
1321     return valid_days;
1322 }
1323
1324 /* object == 0 for a key, and 1 for a sig */
1325 u32
1326 ask_expire_interval(int object)
1327 {
1328     char *answer;
1329     int valid_days=0;
1330     u32 interval = 0;
1331
1332     switch(object)
1333       {
1334       case 0:
1335         tty_printf(_("Please specify how long the key should be valid.\n"
1336                      "         0 = key does not expire\n"
1337                      "      <n>  = key expires in n days\n"
1338                      "      <n>w = key expires in n weeks\n"
1339                      "      <n>m = key expires in n months\n"
1340                      "      <n>y = key expires in n years\n"));
1341         break;
1342
1343       case 1:
1344         tty_printf(_("Please specify how long the signature should be valid.\n"
1345                      "         0 = signature does not expire\n"
1346                      "      <n>  = signature expires in n days\n"
1347                      "      <n>w = signature expires in n weeks\n"
1348                      "      <n>m = signature expires in n months\n"
1349                      "      <n>y = signature expires in n years\n"));
1350         break;
1351
1352       default:
1353         BUG();
1354       }
1355
1356     /* Note: The elgamal subkey for DSA has no expiration date because
1357      * it must be signed with the DSA key and this one has the expiration
1358      * date */
1359
1360     answer = NULL;
1361     for(;;) {
1362         u32 curtime=make_timestamp();
1363
1364         m_free(answer);
1365         if(object==0)
1366           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1367         else
1368           answer = cpr_get("siggen.valid",_("Signature is valid for? (0) "));
1369         cpr_kill_prompt();
1370         trim_spaces(answer);
1371         valid_days = parse_expire_string( answer );
1372         if( valid_days < 0 ) {
1373             tty_printf(_("invalid value\n"));
1374             continue;
1375         }
1376
1377         if( !valid_days ) {
1378             tty_printf(_("%s does not expire at all\n"),
1379                        object==0?"Key":"Signature");
1380             interval = 0;
1381         }
1382         else {
1383             interval = valid_days * 86400L;
1384             /* print the date when the key expires */
1385             tty_printf(_("%s expires at %s\n"),
1386                         object==0?"Key":"Signature",
1387                         asctimestamp((ulong)(curtime + interval) ) );
1388             /* FIXME: This check yields warning on alhas:
1389                write a configure check and to this check here only for 32 bit machines */
1390             if( (time_t)((ulong)(curtime+interval)) < 0 )
1391                 tty_printf(_("Your system can't display dates beyond 2038.\n"
1392                     "However, it will be correctly handled up to 2106.\n"));
1393         }
1394
1395         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1396                                             _("Is this correct (y/n)? ")) )
1397             break;
1398     }
1399     m_free(answer);
1400     return interval;
1401 }
1402
1403 u32
1404 ask_expiredate()
1405 {
1406     u32 x = ask_expire_interval(0);
1407     return x? make_timestamp() + x : 0;
1408 }
1409
1410 static int
1411 has_invalid_email_chars( const char *s )
1412 {
1413     int at_seen=0;
1414     static char valid_chars[] = "01234567890_-."
1415                                 "abcdefghijklmnopqrstuvwxyz"
1416                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1417
1418     for( ; *s; s++ ) {
1419         if( *s & 0x80 )
1420             return 1;
1421         if( *s == '@' )
1422             at_seen=1;
1423         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1424             return 1;
1425         else if( at_seen && !strchr( valid_chars, *s ) )
1426             return 1;
1427     }
1428     return 0;
1429 }
1430
1431
1432 static char *
1433 ask_user_id( int mode )
1434 {
1435     char *answer;
1436     char *aname, *acomment, *amail, *uid;
1437
1438     if( !mode )
1439         tty_printf( _("\n"
1440 "You need a User-ID to identify your key; the software constructs the user id\n"
1441 "from Real Name, Comment and Email Address in this form:\n"
1442 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1443     uid = aname = acomment = amail = NULL;
1444     for(;;) {
1445         char *p;
1446         int fail=0;
1447
1448         if( !aname ) {
1449             for(;;) {
1450                 m_free(aname);
1451                 aname = cpr_get("keygen.name",_("Real name: "));
1452                 trim_spaces(aname);
1453                 cpr_kill_prompt();
1454
1455                 if( opt.allow_freeform_uid )
1456                     break;
1457
1458                 if( strpbrk( aname, "<>" ) )
1459                     tty_printf(_("Invalid character in name\n"));
1460                 else if( digitp(aname) )
1461                     tty_printf(_("Name may not start with a digit\n"));
1462                 else if( strlen(aname) < 5 )
1463                     tty_printf(_("Name must be at least 5 characters long\n"));
1464                 else
1465                     break;
1466             }
1467         }
1468         if( !amail ) {
1469             for(;;) {
1470                 m_free(amail);
1471                 amail = cpr_get("keygen.email",_("Email address: "));
1472                 trim_spaces(amail);
1473                 cpr_kill_prompt();
1474                 if( !*amail || opt.allow_freeform_uid )
1475                     break;   /* no email address is okay */
1476                 else if( has_invalid_email_chars(amail)
1477                          || string_count_chr(amail,'@') != 1
1478                          || *amail == '@'
1479                          || amail[strlen(amail)-1] == '@'
1480                          || amail[strlen(amail)-1] == '.'
1481                          || strstr(amail, "..") )
1482                     tty_printf(_("Not a valid email address\n"));
1483                 else
1484                     break;
1485             }
1486         }
1487         if( !acomment ) {
1488             for(;;) {
1489                 m_free(acomment);
1490                 acomment = cpr_get("keygen.comment",_("Comment: "));
1491                 trim_spaces(acomment);
1492                 cpr_kill_prompt();
1493                 if( !*acomment )
1494                     break;   /* no comment is okay */
1495                 else if( strpbrk( acomment, "()" ) )
1496                     tty_printf(_("Invalid character in comment\n"));
1497                 else
1498                     break;
1499             }
1500         }
1501
1502
1503         m_free(uid);
1504         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1505         p = stpcpy(p, aname );
1506         if( *acomment )
1507             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1508         if( *amail )
1509             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1510
1511         /* append a warning if we do not have dev/random
1512          * or it is switched into  quick testmode */
1513         if( quick_random_gen(-1) )
1514             strcpy(p, " (INSECURE!)" );
1515
1516         /* print a note in case that UTF8 mapping has to be done */
1517         for(p=uid; *p; p++ ) {
1518             if( *p & 0x80 ) {
1519                 tty_printf(_("You are using the `%s' character set.\n"),
1520                            get_native_charset() );
1521                 break;
1522             }
1523         }
1524
1525         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1526         /* fixme: add a warning if this user-id already exists */
1527         if( !*amail && !opt.allow_freeform_uid
1528             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1529             fail = 1;
1530             tty_printf(_("Please don't put the email address "
1531                           "into the real name or the comment\n") );
1532         }
1533
1534         for(;;) {
1535             const char *ansstr = _("NnCcEeOoQq");
1536
1537             if( strlen(ansstr) != 10 )
1538                 BUG();
1539             if( cpr_enabled() ) {
1540                 answer = m_strdup(ansstr+6);
1541                 answer[1] = 0;
1542             }
1543             else {
1544                 answer = cpr_get("keygen.userid.cmd", fail?
1545                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1546                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1547                 cpr_kill_prompt();
1548             }
1549             if( strlen(answer) > 1 )
1550                 ;
1551             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1552                 m_free(aname); aname = NULL;
1553                 break;
1554             }
1555             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1556                 m_free(acomment); acomment = NULL;
1557                 break;
1558             }
1559             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1560                 m_free(amail); amail = NULL;
1561                 break;
1562             }
1563             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1564                 if( fail ) {
1565                     tty_printf(_("Please correct the error first\n"));
1566                 }
1567                 else {
1568                     m_free(aname); aname = NULL;
1569                     m_free(acomment); acomment = NULL;
1570                     m_free(amail); amail = NULL;
1571                     break;
1572                 }
1573             }
1574             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1575                 m_free(aname); aname = NULL;
1576                 m_free(acomment); acomment = NULL;
1577                 m_free(amail); amail = NULL;
1578                 m_free(uid); uid = NULL;
1579                 break;
1580             }
1581             m_free(answer);
1582         }
1583         m_free(answer);
1584         if( !amail && !acomment && !amail )
1585             break;
1586         m_free(uid); uid = NULL;
1587     }
1588     if( uid ) {
1589         char *p = native_to_utf8( uid );
1590         m_free( uid );
1591         uid = p;
1592     }
1593     return uid;
1594 }
1595
1596
1597 static DEK *
1598 do_ask_passphrase( STRING2KEY **ret_s2k )
1599 {
1600     DEK *dek = NULL;
1601     STRING2KEY *s2k;
1602     const char *errtext = NULL;
1603
1604     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1605
1606     s2k = m_alloc_secure( sizeof *s2k );
1607     for(;;) {
1608         s2k->mode = opt.s2k_mode;
1609         s2k->hash_algo = opt.s2k_digest_algo;
1610         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1611                                  errtext, NULL);
1612         if( !dek ) {
1613             errtext = N_("passphrase not correctly repeated; try again");
1614             tty_printf(_("%s.\n"), _(errtext));
1615         }
1616         else if( !dek->keylen ) {
1617             m_free(dek); dek = NULL;
1618             m_free(s2k); s2k = NULL;
1619             tty_printf(_(
1620             "You don't want a passphrase - this is probably a *bad* idea!\n"
1621             "I will do it anyway.  You can change your passphrase at any time,\n"
1622             "using this program with the option \"--edit-key\".\n\n"));
1623             break;
1624         }
1625         else
1626             break; /* okay */
1627     }
1628     *ret_s2k = s2k;
1629     return dek;
1630 }
1631
1632
1633 static int
1634 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1635            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
1636            int is_subkey )
1637 {
1638   int rc=0;
1639
1640   if( !opt.batch )
1641     tty_printf(_(
1642 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1643 "some other action (type on the keyboard, move the mouse, utilize the\n"
1644 "disks) during the prime generation; this gives the random number\n"
1645 "generator a better chance to gain enough entropy.\n") );
1646
1647   if( algo == PUBKEY_ALGO_ELGAMAL_E )
1648     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1649                  is_subkey);
1650   else if( algo == PUBKEY_ALGO_DSA )
1651     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1652                  is_subkey);
1653   else if( algo == PUBKEY_ALGO_RSA )
1654     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
1655                  is_subkey);
1656   else
1657     BUG();
1658
1659 #ifdef ENABLE_COMMENT_PACKETS
1660   if( !rc ) {
1661     add_kbnode( pub_root,
1662                 make_comment_node("#created by GNUPG v" VERSION " ("
1663                                   PRINTABLE_OS_NAME ")"));
1664     add_kbnode( sec_root,
1665                 make_comment_node("#created by GNUPG v" VERSION " ("
1666                                   PRINTABLE_OS_NAME ")"));
1667   }
1668 #endif
1669   return rc;
1670 }
1671
1672
1673 /****************
1674  * Generate a new user id packet, or return NULL if canceled
1675  */
1676 PKT_user_id *
1677 generate_user_id()
1678 {
1679     PKT_user_id *uid;
1680     char *p;
1681     size_t n;
1682
1683     p = ask_user_id( 1 );
1684     if( !p )
1685         return NULL;
1686     n = strlen(p);
1687     uid = m_alloc_clear( sizeof *uid + n - 1 );
1688     uid->len = n;
1689     strcpy(uid->name, p);
1690     uid->ref = 1;
1691     return uid;
1692 }
1693
1694
1695 static void
1696 release_parameter_list( struct para_data_s *r )
1697 {
1698     struct para_data_s *r2;
1699
1700     for( ; r ; r = r2 ) {
1701         r2 = r->next;
1702         if( r->key == pPASSPHRASE_DEK )
1703             m_free( r->u.dek );
1704         else if( r->key == pPASSPHRASE_S2K )
1705             m_free( r->u.s2k );
1706
1707         m_free(r);
1708     }
1709 }
1710
1711 static struct para_data_s *
1712 get_parameter( struct para_data_s *para, enum para_name key )
1713 {
1714     struct para_data_s *r;
1715
1716     for( r = para; r && r->key != key; r = r->next )
1717         ;
1718     return r;
1719 }
1720
1721 static const char *
1722 get_parameter_value( struct para_data_s *para, enum para_name key )
1723 {
1724     struct para_data_s *r = get_parameter( para, key );
1725     return (r && *r->u.value)? r->u.value : NULL;
1726 }
1727
1728 static int
1729 get_parameter_algo( struct para_data_s *para, enum para_name key )
1730 {
1731     int i;
1732     struct para_data_s *r = get_parameter( para, key );
1733     if( !r )
1734         return -1;
1735     if( digitp( r->u.value ) )
1736         i = atoi( r->u.value );
1737     else
1738         i = string_to_pubkey_algo( r->u.value );
1739     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1740       i = 0; /* we don't want to allow generation of these algorithms */
1741     return i;
1742 }
1743
1744 /* 
1745  * parse the usage parameter and set the keyflags.  Return true on error.
1746  */
1747 static int
1748 parse_parameter_usage (const char *fname,
1749                        struct para_data_s *para, enum para_name key)
1750 {
1751     struct para_data_s *r = get_parameter( para, key );
1752     char *p, *pn;
1753     unsigned int use;
1754
1755     if( !r )
1756         return 0; /* none (this is an optional parameter)*/
1757     
1758     use = 0;
1759     pn = r->u.value;
1760     while ( (p = strsep (&pn, " \t,")) ) {
1761         if ( !*p)
1762             ;
1763         else if ( !ascii_strcasecmp (p, "sign") )
1764             use |= PUBKEY_USAGE_SIG;
1765         else if ( !ascii_strcasecmp (p, "encrypt") )
1766             use |= PUBKEY_USAGE_ENC;
1767         else if ( !ascii_strcasecmp (p, "auth") )
1768             use |= PUBKEY_USAGE_AUTH;
1769         else {
1770             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1771             return -1; /* error */
1772         }
1773     }
1774     r->u.usage = use;
1775     return 0;
1776 }
1777
1778 static int
1779 parse_revocation_key (const char *fname,
1780                       struct para_data_s *para, enum para_name key)
1781 {
1782   struct para_data_s *r = get_parameter( para, key );
1783   struct revocation_key revkey;
1784   char *pn;
1785   int i;
1786
1787   if( !r )
1788     return 0; /* none (this is an optional parameter) */
1789
1790   pn = r->u.value;
1791
1792   revkey.class=0x80;
1793   revkey.algid=atoi(pn);
1794   if(!revkey.algid)
1795     goto fail;
1796
1797   /* Skip to the fpr */
1798   while(*pn && *pn!=':')
1799     pn++;
1800
1801   if(*pn!=':')
1802     goto fail;
1803
1804   pn++;
1805
1806   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1807     {
1808       int c=hextobyte(pn);
1809       if(c==-1)
1810         goto fail;
1811
1812       revkey.fpr[i]=c;
1813     }
1814
1815   /* skip to the tag */
1816   while(*pn && *pn!='s' && *pn!='S')
1817     pn++;
1818
1819   if(ascii_strcasecmp(pn,"sensitive")==0)
1820     revkey.class|=0x40;
1821
1822   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
1823
1824   return 0;
1825
1826   fail:
1827   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
1828   return -1; /* error */
1829 }
1830
1831
1832 static u32
1833 get_parameter_u32( struct para_data_s *para, enum para_name key )
1834 {
1835     struct para_data_s *r = get_parameter( para, key );
1836
1837     if( !r )
1838         return 0;
1839     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1840         return r->u.expire;
1841     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
1842         return r->u.usage;
1843
1844     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1845 }
1846
1847 static unsigned int
1848 get_parameter_uint( struct para_data_s *para, enum para_name key )
1849 {
1850     return get_parameter_u32( para, key );
1851 }
1852
1853 static DEK *
1854 get_parameter_dek( struct para_data_s *para, enum para_name key )
1855 {
1856     struct para_data_s *r = get_parameter( para, key );
1857     return r? r->u.dek : NULL;
1858 }
1859
1860 static STRING2KEY *
1861 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1862 {
1863     struct para_data_s *r = get_parameter( para, key );
1864     return r? r->u.s2k : NULL;
1865 }
1866
1867 static struct revocation_key *
1868 get_parameter_revkey( struct para_data_s *para, enum para_name key )
1869 {
1870     struct para_data_s *r = get_parameter( para, key );
1871     return r? &r->u.revkey : NULL;
1872 }
1873
1874 static int
1875 proc_parameter_file( struct para_data_s *para, const char *fname,
1876                      struct output_control_s *outctrl, int card )
1877 {
1878     struct para_data_s *r;
1879     const char *s1, *s2, *s3;
1880     size_t n;
1881     char *p;
1882     int i;
1883
1884     /* check that we have all required parameters */
1885     assert( get_parameter( para, pKEYTYPE ) );
1886     i = get_parameter_algo( para, pKEYTYPE );
1887     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
1888         r = get_parameter( para, pKEYTYPE );
1889         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1890         return -1;
1891     }
1892
1893     if (parse_parameter_usage (fname, para, pKEYUSAGE))
1894         return -1;
1895
1896     i = get_parameter_algo( para, pSUBKEYTYPE );
1897     if( i > 0 && check_pubkey_algo( i ) ) {
1898         r = get_parameter( para, pSUBKEYTYPE );
1899         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1900         return -1;
1901     }
1902     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
1903         return -1;
1904
1905
1906     if( !get_parameter_value( para, pUSERID ) ) {
1907         /* create the formatted user ID */
1908         s1 = get_parameter_value( para, pNAMEREAL );
1909         s2 = get_parameter_value( para, pNAMECOMMENT );
1910         s3 = get_parameter_value( para, pNAMEEMAIL );
1911         if( s1 || s2 || s3 ) {
1912             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1913             r = m_alloc_clear( sizeof *r + n + 20 );
1914             r->key = pUSERID;
1915             p = r->u.value;
1916             if( s1 )
1917                 p = stpcpy(p, s1 );
1918             if( s2 )
1919                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1920             if( s3 )
1921                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1922             r->next = para;
1923             para = r;
1924         }
1925     }
1926
1927     /* Set preferences, if any. */
1928     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
1929
1930     /* Set revoker, if any. */
1931     if (parse_revocation_key (fname, para, pREVOKER))
1932       return -1;
1933
1934     /* make DEK and S2K from the Passphrase */
1935     r = get_parameter( para, pPASSPHRASE );
1936     if( r && *r->u.value ) {
1937         /* we have a plain text passphrase - create a DEK from it.
1938          * It is a little bit ridiculous to keep it ih secure memory
1939          * but becuase we do this alwasy, why not here */
1940         STRING2KEY *s2k;
1941         DEK *dek;
1942
1943         s2k = m_alloc_secure( sizeof *s2k );
1944         s2k->mode = opt.s2k_mode;
1945         s2k->hash_algo = opt.s2k_digest_algo;
1946         set_next_passphrase( r->u.value );
1947         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
1948                                  NULL, NULL);
1949         set_next_passphrase( NULL );
1950         assert( dek );
1951         memset( r->u.value, 0, strlen(r->u.value) );
1952
1953         r = m_alloc_clear( sizeof *r );
1954         r->key = pPASSPHRASE_S2K;
1955         r->u.s2k = s2k;
1956         r->next = para;
1957         para = r;
1958         r = m_alloc_clear( sizeof *r );
1959         r->key = pPASSPHRASE_DEK;
1960         r->u.dek = dek;
1961         r->next = para;
1962         para = r;
1963     }
1964
1965     /* make KEYEXPIRE from Expire-Date */
1966     r = get_parameter( para, pEXPIREDATE );
1967     if( r && *r->u.value ) {
1968         i = parse_expire_string( r->u.value );
1969         if( i < 0 ) {
1970             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1971             return -1;
1972         }
1973         r->u.expire = i * 86400L;
1974         r->key = pKEYEXPIRE;  /* change hat entry */
1975         /* also set it for the subkey */
1976         r = m_alloc_clear( sizeof *r + 20 );
1977         r->key = pSUBKEYEXPIRE;
1978         r->u.expire = i * 86400L;
1979         r->next = para;
1980         para = r;
1981     }
1982
1983     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
1984         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
1985         return -1;
1986     }
1987
1988     do_generate_keypair( para, outctrl, card );
1989     return 0;
1990 }
1991
1992
1993 /****************
1994  * Kludge to allow non interactive key generation controlled
1995  * by a parameter file (which currently is only stdin)
1996  * Note, that string parameters are expected to be in UTF-8
1997  */
1998 static void
1999 read_parameter_file( const char *fname )
2000 {
2001     static struct { const char *name;
2002                     enum para_name key;
2003     } keywords[] = {
2004         { "Key-Type",       pKEYTYPE},
2005         { "Key-Length",     pKEYLENGTH },
2006         { "Key-Usage",      pKEYUSAGE },
2007         { "Subkey-Type",    pSUBKEYTYPE },
2008         { "Subkey-Length",  pSUBKEYLENGTH },
2009         { "Subkey-Usage",   pSUBKEYUSAGE },
2010         { "Name-Real",      pNAMEREAL },
2011         { "Name-Email",     pNAMEEMAIL },
2012         { "Name-Comment",   pNAMECOMMENT },
2013         { "Expire-Date",    pEXPIREDATE },
2014         { "Passphrase",     pPASSPHRASE },
2015         { "Preferences",    pPREFERENCES },
2016         { "Revoker",        pREVOKER },
2017         { NULL, 0 }
2018     };
2019     FILE *fp;
2020     char line[1024], *p;
2021     int lnr;
2022     const char *err = NULL;
2023     struct para_data_s *para, *r;
2024     int i;
2025     struct output_control_s outctrl;
2026
2027     memset( &outctrl, 0, sizeof( outctrl ) );
2028
2029     if( !fname || !*fname || !strcmp(fname,"-") ) {
2030         fp = stdin;
2031         fname = "-";
2032     }
2033     else {
2034         fp = fopen( fname, "r" );
2035         if( !fp ) {
2036             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
2037             return;
2038         }
2039     }
2040
2041     lnr = 0;
2042     err = NULL;
2043     para = NULL;
2044     while( fgets( line, DIM(line)-1, fp ) ) {
2045         char *keyword, *value;
2046
2047         lnr++;
2048         if( *line && line[strlen(line)-1] != '\n' ) {
2049             err = "line too long";
2050             break;
2051         }
2052         for( p = line; isspace(*(byte*)p); p++ )
2053             ;
2054         if( !*p || *p == '#' )
2055             continue;
2056         keyword = p;
2057         if( *keyword == '%' ) {
2058             for( ; !isspace(*(byte*)p); p++ )
2059                 ;
2060             if( *p )
2061                 *p++ = 0;
2062             for( ; isspace(*(byte*)p); p++ )
2063                 ;
2064             value = p;
2065             trim_trailing_ws( value, strlen(value) );
2066             if( !ascii_strcasecmp( keyword, "%echo" ) )
2067                 log_info("%s\n", value );
2068             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2069                 outctrl.dryrun = 1;
2070             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2071                 outctrl.lnr = lnr;
2072                 proc_parameter_file( para, fname, &outctrl, 0 );
2073                 release_parameter_list( para );
2074                 para = NULL;
2075             }
2076             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2077                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2078                     ; /* still the same file - ignore it */
2079                 else {
2080                     m_free( outctrl.pub.newfname );
2081                     outctrl.pub.newfname = m_strdup( value );
2082                     outctrl.use_files = 1;
2083                 }
2084             }
2085             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2086                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2087                     ; /* still the same file - ignore it */
2088                 else {
2089                    m_free( outctrl.sec.newfname );
2090                    outctrl.sec.newfname = m_strdup( value );
2091                    outctrl.use_files = 1;
2092                 }
2093             }
2094             else
2095                 log_info("skipping control `%s' (%s)\n", keyword, value );
2096
2097
2098             continue;
2099         }
2100
2101
2102         if( !(p = strchr( p, ':' )) || p == keyword ) {
2103             err = "missing colon";
2104             break;
2105         }
2106         if( *p )
2107             *p++ = 0;
2108         for( ; isspace(*(byte*)p); p++ )
2109             ;
2110         if( !*p ) {
2111             err = "missing argument";
2112             break;
2113         }
2114         value = p;
2115         trim_trailing_ws( value, strlen(value) );
2116
2117         for(i=0; keywords[i].name; i++ ) {
2118             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2119                 break;
2120         }
2121         if( !keywords[i].name ) {
2122             err = "unknown keyword";
2123             break;
2124         }
2125         if( keywords[i].key != pKEYTYPE && !para ) {
2126             err = "parameter block does not start with \"Key-Type\"";
2127             break;
2128         }
2129
2130         if( keywords[i].key == pKEYTYPE && para ) {
2131             outctrl.lnr = lnr;
2132             proc_parameter_file( para, fname, &outctrl, 0 );
2133             release_parameter_list( para );
2134             para = NULL;
2135         }
2136         else {
2137             for( r = para; r; r = r->next ) {
2138                 if( r->key == keywords[i].key )
2139                     break;
2140             }
2141             if( r ) {
2142                 err = "duplicate keyword";
2143                 break;
2144             }
2145         }
2146         r = m_alloc_clear( sizeof *r + strlen( value ) );
2147         r->lnr = lnr;
2148         r->key = keywords[i].key;
2149         strcpy( r->u.value, value );
2150         r->next = para;
2151         para = r;
2152     }
2153     if( err )
2154         log_error("%s:%d: %s\n", fname, lnr, err );
2155     else if( ferror(fp) ) {
2156         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
2157     }
2158     else if( para ) {
2159         outctrl.lnr = lnr;
2160         proc_parameter_file( para, fname, &outctrl, 0 );
2161     }
2162
2163     if( outctrl.use_files ) { /* close open streams */
2164         iobuf_close( outctrl.pub.stream );
2165         iobuf_close( outctrl.sec.stream );
2166
2167         /* Must invalidate that ugly cache to actually close it.  */
2168         if (outctrl.pub.fname)
2169           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2170         if (outctrl.sec.fname)
2171           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2172
2173         m_free( outctrl.pub.fname );
2174         m_free( outctrl.pub.newfname );
2175         m_free( outctrl.sec.fname );
2176         m_free( outctrl.sec.newfname );
2177     }
2178
2179     release_parameter_list( para );
2180     if( strcmp( fname, "-" ) )
2181         fclose(fp);
2182 }
2183
2184
2185 /*
2186  * Generate a keypair (fname is only used in batch mode) If
2187  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2188  * OpenPGP Card.
2189  */
2190 void
2191 generate_keypair( const char *fname, const char *card_serialno )
2192 {
2193   unsigned int nbits;
2194   char *uid = NULL;
2195   DEK *dek;
2196   STRING2KEY *s2k;
2197   int algo;
2198   unsigned int use;
2199   int both = 0;
2200   u32 expire;
2201   struct para_data_s *para = NULL;
2202   struct para_data_s *r;
2203   struct output_control_s outctrl;
2204   
2205   memset( &outctrl, 0, sizeof( outctrl ) );
2206   
2207   if (opt.batch && card_serialno)
2208     {
2209       /* We don't yet support unattended key generation. */
2210       log_error (_("sorry, can't do this in batch mode\n"));
2211       return;
2212     }
2213   
2214    if (opt.batch)
2215      {
2216        read_parameter_file( fname );
2217        return;
2218      }
2219
2220    if (card_serialno)
2221      {
2222 #ifdef ENABLE_CARD_SUPPORT
2223        r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2224        r->key = pSERIALNO;
2225        strcpy( r->u.value, card_serialno);
2226        r->next = para;
2227        para = r;
2228        
2229        algo = PUBKEY_ALGO_RSA;
2230        
2231        r = xcalloc (1, sizeof *r + 20 );
2232        r->key = pKEYTYPE;
2233        sprintf( r->u.value, "%d", algo );
2234        r->next = para;
2235        para = r;
2236        r = xcalloc (1, sizeof *r + 20 );
2237        r->key = pKEYUSAGE;
2238        strcpy (r->u.value, "sign");
2239        r->next = para;
2240        para = r;
2241        
2242        r = xcalloc (1, sizeof *r + 20 );
2243        r->key = pSUBKEYTYPE;
2244        sprintf( r->u.value, "%d", algo );
2245        r->next = para;
2246        para = r;
2247        r = xcalloc (1, sizeof *r + 20 );
2248        r->key = pSUBKEYUSAGE;
2249        strcpy (r->u.value, "encrypt");
2250        r->next = para;
2251        para = r;
2252        
2253        r = xcalloc (1, sizeof *r + 20 );
2254        r->key = pAUTHKEYTYPE;
2255        sprintf( r->u.value, "%d", algo );
2256        r->next = para;
2257        para = r;
2258 #endif /*ENABLE_CARD_SUPPORT*/
2259      }
2260    else
2261      {
2262        algo = ask_algo( 0, &use );
2263        if( !algo )
2264          { /* default: DSA with ElG subkey of the specified size */
2265            both = 1;
2266            r = m_alloc_clear( sizeof *r + 20 );
2267            r->key = pKEYTYPE;
2268            sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2269            r->next = para;
2270            para = r;
2271            tty_printf(_("DSA keypair will have 1024 bits.\n"));
2272            r = m_alloc_clear( sizeof *r + 20 );
2273            r->key = pKEYLENGTH;
2274            strcpy( r->u.value, "1024" );
2275            r->next = para;
2276            para = r;
2277            r = m_alloc_clear( sizeof *r + 20 );
2278            r->key = pKEYUSAGE;
2279            strcpy( r->u.value, "sign" );
2280            r->next = para;
2281            para = r;
2282            
2283            algo = PUBKEY_ALGO_ELGAMAL_E;
2284            r = m_alloc_clear( sizeof *r + 20 );
2285            r->key = pSUBKEYTYPE;
2286            sprintf( r->u.value, "%d", algo );
2287            r->next = para;
2288            para = r;
2289            r = m_alloc_clear( sizeof *r + 20 );
2290            r->key = pSUBKEYUSAGE;
2291            strcpy( r->u.value, "encrypt" );
2292            r->next = para;
2293            para = r;
2294          }
2295        else 
2296          {
2297            r = m_alloc_clear( sizeof *r + 20 );
2298            r->key = pKEYTYPE;
2299            sprintf( r->u.value, "%d", algo );
2300            r->next = para;
2301            para = r;
2302            
2303            if (use)
2304              {
2305                r = m_alloc_clear( sizeof *r + 20 );
2306                r->key = pKEYUSAGE;
2307                sprintf( r->u.value, "%s%s",
2308                         (use & PUBKEY_USAGE_SIG)? "sign ":"",
2309                         (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
2310                r->next = para;
2311                para = r;
2312              }
2313            
2314          }
2315        
2316        nbits = ask_keysize( algo );
2317        r = m_alloc_clear( sizeof *r + 20 );
2318        r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2319        sprintf( r->u.value, "%u", nbits);
2320        r->next = para;
2321        para = r;
2322      }
2323
2324    expire = ask_expire_interval(0);
2325     r = m_alloc_clear( sizeof *r + 20 );
2326     r->key = pKEYEXPIRE;
2327     r->u.expire = expire;
2328     r->next = para;
2329     para = r;
2330     r = m_alloc_clear( sizeof *r + 20 );
2331     r->key = pSUBKEYEXPIRE;
2332     r->u.expire = expire;
2333     r->next = para;
2334     para = r;
2335
2336     uid = ask_user_id(0);
2337     if( !uid ) 
2338       {
2339         log_error(_("Key generation canceled.\n"));
2340         release_parameter_list( para );
2341         return;
2342       }
2343     r = m_alloc_clear( sizeof *r + strlen(uid) );
2344     r->key = pUSERID;
2345     strcpy( r->u.value, uid );
2346     r->next = para;
2347     para = r;
2348     
2349     dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2350     if( dek )
2351       {
2352         r = m_alloc_clear( sizeof *r );
2353         r->key = pPASSPHRASE_DEK;
2354         r->u.dek = dek;
2355         r->next = para;
2356         para = r;
2357         r = m_alloc_clear( sizeof *r );
2358         r->key = pPASSPHRASE_S2K;
2359         r->u.s2k = s2k;
2360         r->next = para;
2361         para = r;
2362       }
2363     
2364     proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2365     release_parameter_list( para );
2366 }
2367
2368
2369 static void
2370 print_status_key_created (int letter, PKT_public_key *pk)
2371 {
2372   byte array[MAX_FINGERPRINT_LEN], *s;
2373   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
2374   size_t i, n;
2375   
2376   p = buf;
2377   *p++ = letter;
2378   *p++ = ' ';
2379   fingerprint_from_pk (pk, array, &n);
2380   s = array;
2381   for (i=0; i < n ; i++, s++, p += 2)
2382     sprintf (p, "%02X", *s);
2383   *p = 0;
2384   write_status_text (STATUS_KEY_CREATED, buf);
2385 }
2386
2387 static void
2388 do_generate_keypair( struct para_data_s *para,
2389                      struct output_control_s *outctrl, int card )
2390 {
2391     KBNODE pub_root = NULL;
2392     KBNODE sec_root = NULL;
2393     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2394     const char *s;
2395     struct revocation_key *revkey;
2396     int rc;
2397     int did_sub = 0;
2398
2399     if( outctrl->dryrun ) {
2400         log_info("dry-run mode - key generation skipped\n");
2401         return;
2402     }
2403
2404
2405     if( outctrl->use_files ) {
2406         if( outctrl->pub.newfname ) {
2407             iobuf_close(outctrl->pub.stream);
2408             outctrl->pub.stream = NULL;
2409             if (outctrl->pub.fname)
2410               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
2411             m_free( outctrl->pub.fname );
2412             outctrl->pub.fname =  outctrl->pub.newfname;
2413             outctrl->pub.newfname = NULL;
2414
2415             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2416             if( !outctrl->pub.stream ) {
2417                 log_error("can't create `%s': %s\n", outctrl->pub.newfname,
2418                                                      strerror(errno) );
2419                 return;
2420             }
2421             if( opt.armor ) {
2422                 outctrl->pub.afx.what = 1;
2423                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2424                                                     &outctrl->pub.afx );
2425             }
2426         }
2427         if( outctrl->sec.newfname ) {
2428             mode_t oldmask;
2429
2430             iobuf_close(outctrl->sec.stream);
2431             outctrl->sec.stream = NULL;
2432             if (outctrl->sec.fname)
2433               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
2434             m_free( outctrl->sec.fname );
2435             outctrl->sec.fname =  outctrl->sec.newfname;
2436             outctrl->sec.newfname = NULL;
2437
2438             oldmask = umask (077);
2439             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2440             umask (oldmask);
2441             if( !outctrl->sec.stream ) {
2442                 log_error("can't create `%s': %s\n", outctrl->sec.newfname,
2443                                                      strerror(errno) );
2444                 return;
2445             }
2446             if( opt.armor ) {
2447                 outctrl->sec.afx.what = 5;
2448                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2449                                                     &outctrl->sec.afx );
2450             }
2451         }
2452         assert( outctrl->pub.stream );
2453         assert( outctrl->sec.stream );
2454         if( opt.verbose ) {
2455             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2456             if (card)
2457               log_info (_("writing secret key stub to `%s'\n"),
2458                         outctrl->sec.fname);
2459             else
2460               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2461         }
2462     }
2463
2464
2465     /* we create the packets as a tree of kbnodes. Because the structure
2466      * we create is known in advance we simply generate a linked list
2467      * The first packet is a dummy comment packet which we flag
2468      * as deleted.  The very first packet must always be a KEY packet.
2469      */
2470     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
2471     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
2472
2473     if (!card)
2474       {
2475         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2476                         get_parameter_uint( para, pKEYLENGTH ),
2477                         pub_root, sec_root,
2478                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2479                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2480                         &pri_sk,
2481                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
2482       }
2483     else
2484       {
2485         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root,
2486                            get_parameter_u32 (para, pKEYEXPIRE), para);
2487         if (!rc)
2488           {
2489             pri_sk = sec_root->next->pkt->pkt.secret_key;
2490             assert (pri_sk);
2491           }
2492       }
2493
2494     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2495       {
2496         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
2497         if(!rc)
2498           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
2499       }
2500
2501     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
2502         write_uid(pub_root, s );
2503         if( !rc )
2504             write_uid(sec_root, s );
2505         if( !rc )
2506             rc = write_selfsig(pub_root, pub_root, pri_sk,
2507                                get_parameter_uint (para, pKEYUSAGE));
2508         if( !rc )
2509             rc = write_selfsig(sec_root, pub_root, pri_sk,
2510                                get_parameter_uint (para, pKEYUSAGE));
2511     }
2512
2513     if( get_parameter( para, pSUBKEYTYPE ) )
2514       {
2515         if (!card)
2516           {
2517             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2518                             get_parameter_uint( para, pSUBKEYLENGTH ),
2519                             pub_root, sec_root,
2520                             get_parameter_dek( para, pPASSPHRASE_DEK ),
2521                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
2522                             &sub_sk,
2523                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
2524           }
2525         else
2526           {
2527             rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
2528                                get_parameter_u32 (para, pKEYEXPIRE), para);
2529           }
2530
2531         if( !rc )
2532           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
2533                                 get_parameter_uint (para, pSUBKEYUSAGE));
2534         if( !rc )
2535           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
2536                                 get_parameter_uint (para, pSUBKEYUSAGE));
2537         did_sub = 1;
2538       }
2539
2540     if (card && get_parameter (para, pAUTHKEYTYPE))
2541       {
2542         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root,
2543                            get_parameter_u32 (para, pKEYEXPIRE), para);
2544         
2545         if (!rc)
2546           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2547         if (!rc)
2548           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
2549       }
2550     
2551     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2552         rc = write_keyblock( outctrl->pub.stream, pub_root );
2553         if( rc )
2554             log_error("can't write public key: %s\n", g10_errstr(rc) );
2555         if( !rc ) {
2556             rc = write_keyblock( outctrl->sec.stream, sec_root );
2557             if( rc )
2558                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2559         }
2560
2561     }
2562     else if( !rc ) { /* write to the standard keyrings */
2563         KEYDB_HANDLE pub_hd = keydb_new (0);
2564         KEYDB_HANDLE sec_hd = keydb_new (1);
2565
2566         /* FIXME: we may have to create the keyring first */
2567         rc = keydb_locate_writable (pub_hd, NULL);
2568         if (rc) 
2569             log_error (_("no writable public keyring found: %s\n"),
2570                        g10_errstr (rc));
2571
2572         if (!rc) {  
2573             rc = keydb_locate_writable (sec_hd, NULL);
2574             if (rc) 
2575                 log_error (_("no writable secret keyring found: %s\n"),
2576                            g10_errstr (rc));
2577         }
2578
2579         if (!rc && opt.verbose) {
2580             log_info(_("writing public key to `%s'\n"),
2581                      keydb_get_resource_name (pub_hd));
2582             if (card)
2583               log_info (_("writing secret key stub to `%s'\n"),
2584                         keydb_get_resource_name (sec_hd));
2585             else
2586               log_info(_("writing secret key to `%s'\n"),
2587                        keydb_get_resource_name (sec_hd));
2588         }
2589
2590         if (!rc) {
2591             rc = keydb_insert_keyblock (pub_hd, pub_root);
2592             if (rc)
2593                 log_error (_("error writing public keyring `%s': %s\n"),
2594                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2595         }
2596
2597         if (!rc) {
2598             rc = keydb_insert_keyblock (sec_hd, sec_root);
2599             if (rc)
2600                 log_error (_("error writing secret keyring `%s': %s\n"),
2601                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2602         }
2603
2604         keydb_release (pub_hd);
2605         keydb_release (sec_hd);
2606
2607         if (!rc) {
2608             int no_enc_rsa =
2609                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2610                 && get_parameter_uint( para, pKEYUSAGE )
2611                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2612             PKT_public_key *pk = find_kbnode (pub_root, 
2613                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2614
2615             keyid_from_pk(pk,pk->main_keyid);
2616             register_trusted_keyid(pk->main_keyid);
2617
2618             update_ownertrust (pk,
2619                                ((get_ownertrust (pk) & ~TRUST_MASK)
2620                                 | TRUST_ULTIMATE ));
2621
2622             if (!opt.batch) {
2623                 tty_printf(_("public and secret key created and signed.\n") );
2624                 tty_printf("\n");
2625                 list_keyblock(pub_root,0,1,NULL);
2626             }
2627             
2628
2629             if( !opt.batch
2630                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2631                      || no_enc_rsa )
2632                 && !get_parameter( para, pSUBKEYTYPE ) )
2633             {
2634                 tty_printf(_("Note that this key cannot be used for "
2635                              "encryption.  You may want to use\n"
2636                              "the command \"--edit-key\" to generate a "
2637                              "secondary key for this purpose.\n") );
2638             }
2639         }
2640     }
2641
2642     if( rc ) {
2643         if( opt.batch )
2644             log_error("key generation failed: %s\n", g10_errstr(rc) );
2645         else
2646             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2647     }
2648     else {
2649         PKT_public_key *pk = find_kbnode (pub_root, 
2650                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2651         print_status_key_created (did_sub? 'B':'P', pk);
2652     }
2653     release_kbnode( pub_root );
2654     release_kbnode( sec_root );
2655
2656     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
2657       free_secret_key(pri_sk); /* shallow copy in card mode. */
2658     if( sub_sk )
2659         free_secret_key(sub_sk);
2660 }
2661
2662
2663 /****************
2664  * add a new subkey to an existing key.
2665  * Returns true if a new key has been generated and put into the keyblocks.
2666  */
2667 int
2668 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2669 {
2670     int okay=0, rc=0;
2671     KBNODE node;
2672     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2673     int algo;
2674     unsigned int use;
2675     u32 expire;
2676     unsigned nbits;
2677     char *passphrase = NULL;
2678     DEK *dek = NULL;
2679     STRING2KEY *s2k = NULL;
2680     u32 cur_time;
2681
2682     /* break out the primary secret key */
2683     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2684     if( !node ) {
2685         log_error("Oops; secret key not found anymore!\n");
2686         goto leave;
2687     }
2688
2689     /* make a copy of the sk to keep the protected one in the keyblock */
2690     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
2691
2692     cur_time = make_timestamp();
2693     if( pri_sk->timestamp > cur_time ) {
2694         ulong d = pri_sk->timestamp - cur_time;
2695         log_info( d==1 ? _("key has been created %lu second "
2696                            "in future (time warp or clock problem)\n")
2697                        : _("key has been created %lu seconds "
2698                            "in future (time warp or clock problem)\n"), d );
2699         if( !opt.ignore_time_conflict ) {
2700             rc = G10ERR_TIME_CONFLICT;
2701             goto leave;
2702         }
2703     }
2704
2705     if (pri_sk->version < 4) {
2706         log_info (_("NOTE: creating subkeys for v3 keys "
2707                     "is not OpenPGP compliant\n"));
2708         goto leave;
2709     }
2710
2711     /* unprotect to get the passphrase */
2712     switch( is_secret_key_protected( pri_sk ) ) {
2713       case -1:
2714         rc = G10ERR_PUBKEY_ALGO;
2715         break;
2716       case 0:
2717         tty_printf("This key is not protected.\n");
2718         break;
2719       default:
2720         tty_printf("Key is protected.\n");
2721         rc = check_secret_key( pri_sk, 0 );
2722         if( !rc )
2723             passphrase = get_last_passphrase();
2724         break;
2725     }
2726     if( rc )
2727         goto leave;
2728
2729     algo = ask_algo( 1, &use );
2730     assert(algo);
2731     nbits = ask_keysize( algo );
2732     expire = ask_expire_interval(0);
2733     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
2734                                                   _("Really create? ") ) )
2735         goto leave;
2736
2737     if( passphrase ) {
2738         s2k = m_alloc_secure( sizeof *s2k );
2739         s2k->mode = opt.s2k_mode;
2740         s2k->hash_algo = opt.s2k_digest_algo;
2741         set_next_passphrase( passphrase );
2742         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2743                                  NULL, NULL );
2744     }
2745
2746     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
2747                                       dek, s2k, &sub_sk, expire, 1 );
2748     if( !rc )
2749         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
2750     if( !rc )
2751         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
2752     if( !rc ) {
2753         okay = 1;
2754         write_status_text (STATUS_KEY_CREATED, "S");
2755     }
2756
2757   leave:
2758     if( rc )
2759         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
2760     m_free( passphrase );
2761     m_free( dek );
2762     m_free( s2k );
2763     /* release the copy of the (now unprotected) secret keys */
2764     if( pri_sk )
2765         free_secret_key(pri_sk);
2766     if( sub_sk )
2767         free_secret_key(sub_sk);
2768     set_next_passphrase( NULL );
2769     return okay;
2770 }
2771
2772
2773 #ifdef ENABLE_CARD_SUPPORT
2774 /* Generate a subkey on a card. */
2775 int
2776 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
2777                           int keyno, const char *serialno)
2778 {
2779   int okay=0, rc=0;
2780   KBNODE node;
2781   PKT_secret_key *pri_sk = NULL;
2782   int algo;
2783   unsigned int use;
2784   u32 expire;
2785   char *passphrase = NULL;
2786   u32 cur_time;
2787   struct para_data_s *para = NULL;
2788
2789   assert (keyno >= 1 && keyno <= 3);
2790
2791   para = xcalloc (1, sizeof *para + strlen (serialno) );
2792   para->key = pSERIALNO;
2793   strcpy (para->u.value, serialno);
2794
2795   /* Break out the primary secret key */
2796   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2797   if(!node)
2798     {
2799       log_error("Oops; secret key not found anymore!\n");
2800       goto leave;
2801     }
2802
2803   /* Make a copy of the sk to keep the protected one in the keyblock */
2804   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
2805
2806   cur_time = make_timestamp();
2807   if (pri_sk->timestamp > cur_time)
2808     {
2809       ulong d = pri_sk->timestamp - cur_time;
2810       log_info (d==1 ? _("key has been created %lu second "
2811                          "in future (time warp or clock problem)\n")
2812                      : _("key has been created %lu seconds "
2813                          "in future (time warp or clock problem)\n"), d );
2814         if (!opt.ignore_time_conflict)
2815           {
2816             rc = G10ERR_TIME_CONFLICT;
2817             goto leave;
2818           }
2819     }
2820
2821   if (pri_sk->version < 4)
2822     {
2823       log_info (_("NOTE: creating subkeys for v3 keys "
2824                   "is not OpenPGP compliant\n"));
2825       goto leave;
2826     }
2827
2828   /* Unprotect to get the passphrase. */
2829   switch( is_secret_key_protected (pri_sk) )
2830     {
2831     case -1:
2832       rc = G10ERR_PUBKEY_ALGO;
2833       break;
2834     case 0:
2835       tty_printf("This key is not protected.\n");
2836       break;
2837     default:
2838       tty_printf("Key is protected.\n");
2839       rc = check_secret_key( pri_sk, 0 );
2840       if (!rc)
2841         passphrase = get_last_passphrase();
2842       break;
2843     }
2844   if (rc)
2845     goto leave;
2846
2847   algo = PUBKEY_ALGO_RSA;
2848   expire = ask_expire_interval (0);
2849   if (keyno == 1)
2850     use = PUBKEY_USAGE_SIG;
2851   else if (keyno == 2)
2852     use = PUBKEY_USAGE_ENC;
2853   else
2854     use = PUBKEY_USAGE_AUTH;
2855   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
2856                                                _("Really create? ") ) )
2857     goto leave;
2858
2859   if (passphrase)
2860     set_next_passphrase (passphrase);
2861   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock, expire, para);
2862   if (!rc)
2863     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, NULL, use);
2864   if (!rc)
2865     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, NULL, use);
2866   if (!rc)
2867     {
2868       okay = 1;
2869       write_status_text (STATUS_KEY_CREATED, "S");
2870     }
2871
2872  leave:
2873   if (rc)
2874     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
2875   m_free (passphrase);
2876   /* Release the copy of the (now unprotected) secret keys. */
2877   if (pri_sk)
2878     free_secret_key (pri_sk);
2879   set_next_passphrase( NULL );
2880   release_parameter_list (para);
2881   return okay;
2882 }
2883 #endif /* !ENABLE_CARD_SUPPORT */
2884
2885
2886 /****************
2887  * Write a keyblock to an output stream
2888  */
2889 static int
2890 write_keyblock( IOBUF out, KBNODE node )
2891 {
2892     for( ; node ; node = node->next ) {
2893         int rc = build_packet( out, node->pkt );
2894         if( rc ) {
2895             log_error("build_packet(%d) failed: %s\n",
2896                         node->pkt->pkttype, g10_errstr(rc) );
2897             return G10ERR_WRITE_FILE;
2898         }
2899     }
2900     return 0;
2901 }
2902
2903
2904 static int
2905 gen_card_key (int algo, int keyno, int is_primary,
2906               KBNODE pub_root, KBNODE sec_root,
2907               u32 expireval, struct para_data_s *para)
2908 {
2909 #ifdef ENABLE_CARD_SUPPORT
2910   int rc;
2911   const char *s;
2912   struct agent_card_genkey_s info;
2913   PACKET *pkt;
2914   PKT_secret_key *sk;
2915   PKT_public_key *pk;
2916
2917   assert (algo == PUBKEY_ALGO_RSA);
2918
2919   rc = agent_scd_genkey (&info, keyno, 1);
2920 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
2921 /*      { */
2922 /*        tty_printf ("\n"); */
2923 /*        log_error ("WARNING: key does already exists!\n"); */
2924 /*        tty_printf ("\n"); */
2925 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
2926 /*                                    _("Replace existing key? "))) */
2927 /*          rc = agent_scd_genkey (&info, keyno, 1); */
2928 /*      } */
2929
2930   if (rc)
2931     {
2932       log_error ("key generation failed: %s\n", gpg_strerror (rc));
2933       return rc;
2934     }
2935   if ( !info.n || !info.e )
2936     {
2937       log_error ("communication error with SCD\n");
2938       mpi_free (info.n);
2939       mpi_free (info.e);
2940       return gpg_error (GPG_ERR_GENERAL);
2941     }
2942   
2943
2944   pk = xcalloc (1, sizeof *pk );
2945   sk = xcalloc (1, sizeof *sk );
2946   sk->timestamp = pk->timestamp = info.created_at;
2947   sk->version = pk->version = 4;
2948   if (expireval)
2949       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
2950   sk->pubkey_algo = pk->pubkey_algo = algo;
2951   pk->pkey[0] = info.n;
2952   pk->pkey[1] = info.e; 
2953   sk->skey[0] = mpi_copy (pk->pkey[0]);
2954   sk->skey[1] = mpi_copy (pk->pkey[1]);
2955   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
2956   sk->is_protected = 1;
2957   sk->protect.s2k.mode = 1002;
2958   s = get_parameter_value (para, pSERIALNO);
2959   if (s)
2960     {
2961       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2962            sk->protect.ivlen++, s += 2)
2963         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2964     }
2965
2966   pkt = xcalloc (1,sizeof *pkt);
2967   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
2968   pkt->pkt.public_key = pk;
2969   add_kbnode(pub_root, new_kbnode( pkt ));
2970
2971   pkt = xcalloc (1,sizeof *pkt);
2972   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
2973   pkt->pkt.secret_key = sk;
2974   add_kbnode(sec_root, new_kbnode( pkt ));
2975
2976   return 0;
2977 #else
2978   return -1;
2979 #endif /*!ENABLE_CARD_SUPPORT*/
2980 }