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