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