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