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