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