See ChangeLog: Tue Jul 25 17:44:15 CEST 2000 Werner Koch
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - generate a key pair
2  *      Copyright (C) 1998, 1999, 2000 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 <gcrypt.h>
30 #include "main.h"
31 #include "packet.h"
32 #include "ttyio.h"
33 #include "options.h"
34 #include "keydb.h"
35 #include "status.h"
36 #include "i18n.h"
37
38 enum para_name {
39   pKEYTYPE,
40   pKEYLENGTH,
41   pSUBKEYTYPE,
42   pSUBKEYLENGTH,
43   pNAMEREAL,
44   pNAMEEMAIL,
45   pNAMECOMMENT,
46   pUSERID,
47   pEXPIREDATE,
48   pKEYEXPIRE, /* in n seconds */
49   pSUBKEYEXPIRE, /* in n seconds */
50   pPASSPHRASE,
51   pPASSPHRASE_DEK,
52   pPASSPHRASE_S2K
53 };
54
55 struct para_data_s {
56     struct para_data_s *next;
57     int lnr;
58     enum para_name key;
59     union {
60        DEK *dek;
61        STRING2KEY *s2k;
62        u32 expire;
63        char value[1];
64     } u;
65 };
66
67 struct output_control_s {
68     int lnr;
69     int dryrun;
70     int use_files;
71     struct {
72         char  *fname;
73         char  *newfname;
74         IOBUF stream;
75         armor_filter_context_t afx;
76     } pub;
77     struct {
78         char  *fname;
79         char  *newfname;
80         IOBUF stream;
81         armor_filter_context_t afx;
82     } sec;
83 };
84
85
86 static void do_generate_keypair( struct para_data_s *para,
87                                  struct output_control_s *outctrl );
88 static int  write_keyblock( IOBUF out, KBNODE node );
89
90
91 static void
92 write_uid( KBNODE root, const char *s )
93 {
94     PACKET *pkt = gcry_xcalloc( 1,sizeof *pkt );
95     size_t n = strlen(s);
96
97     pkt->pkttype = PKT_USER_ID;
98     pkt->pkt.user_id = gcry_xcalloc( 1, sizeof *pkt->pkt.user_id + n - 1 );
99     pkt->pkt.user_id->len = n;
100     strcpy(pkt->pkt.user_id->name, s);
101     add_kbnode( root, new_kbnode( pkt ) );
102 }
103
104
105
106 int
107 keygen_add_key_expire( PKT_signature *sig, void *opaque )
108 {
109     PKT_public_key *pk = opaque;
110     byte buf[8];
111     u32  u;
112
113     if( pk->expiredate ) {
114         u = pk->expiredate > pk->timestamp? pk->expiredate - pk->timestamp
115                                           : pk->timestamp;
116         buf[0] = (u >> 24) & 0xff;
117         buf[1] = (u >> 16) & 0xff;
118         buf[2] = (u >>  8) & 0xff;
119         buf[3] = u & 0xff;
120         build_sig_subpkt( sig, SIGSUBPKT_KEY_EXPIRE, buf, 4 );
121     }
122
123     return 0;
124 }
125
126
127 /****************
128  * Add preference to the self signature packet.
129  * This is only called for packets with version > 3.
130  */
131 int
132 keygen_add_std_prefs( PKT_signature *sig, void *opaque )
133 {
134     byte buf[8];
135
136     keygen_add_key_expire( sig, opaque );
137
138     buf[0] = GCRY_CIPHER_TWOFISH;
139     buf[1] = GCRY_CIPHER_BLOWFISH;
140     buf[2] = GCRY_CIPHER_CAST5;
141     build_sig_subpkt( sig, SIGSUBPKT_PREF_SYM, buf, 3 );
142
143     buf[0] = GCRY_MD_RMD160;
144     buf[1] = GCRY_MD_SHA1;
145     build_sig_subpkt( sig, SIGSUBPKT_PREF_HASH, buf, 2 );
146
147     buf[0] = 2;
148     buf[1] = 1;
149     build_sig_subpkt( sig, SIGSUBPKT_PREF_COMPR, buf, 2 );
150
151     buf[0] = 0x80; /* no modify - It is reasonable that a key holder
152                     * has the possibility to reject signatures from users
153                     * who are known to sign everything without any
154                     * validation - so a signed key should be send
155                     * to the holder who in turn can put it on a keyserver
156                     */
157     build_sig_subpkt( sig, SIGSUBPKT_KS_FLAGS, buf, 1 );
158
159     return 0;
160 }
161
162
163
164 static int
165 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk )
166 {
167     PACKET *pkt;
168     PKT_signature *sig;
169     PKT_user_id *uid;
170     int rc=0;
171     KBNODE node;
172     PKT_public_key *pk;
173
174     if( opt.verbose )
175         log_info(_("writing self signature\n"));
176
177     /* get the uid packet from the list */
178     node = find_kbnode( root, PKT_USER_ID );
179     if( !node )
180         BUG(); /* no user id packet in tree */
181     uid = node->pkt->pkt.user_id;
182     /* get the pk packet from the pub_tree */
183     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
184     if( !node )
185         BUG();
186     pk = node->pkt->pkt.public_key;
187
188     /* and make the signature */
189     rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0,
190                              keygen_add_std_prefs, pk );
191     if( rc ) {
192         log_error("make_keysig_packet failed: %s\n", gpg_errstr(rc) );
193         return rc;
194     }
195
196     pkt = gcry_xcalloc( 1, sizeof *pkt );
197     pkt->pkttype = PKT_SIGNATURE;
198     pkt->pkt.signature = sig;
199     add_kbnode( root, new_kbnode( pkt ) );
200     return rc;
201 }
202
203 static int
204 write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk )
205 {
206     PACKET *pkt;
207     PKT_signature *sig;
208     int rc=0;
209     KBNODE node;
210     PKT_public_key *pk, *subpk;
211
212     if( opt.verbose )
213         log_info(_("writing key binding signature\n"));
214
215     /* get the pk packet from the pub_tree */
216     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
217     if( !node )
218         BUG();
219     pk = node->pkt->pkt.public_key;
220     /* find the last subkey */
221     subpk = NULL;
222     for(node=pub_root; node; node = node->next ) {
223         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
224             subpk = node->pkt->pkt.public_key;
225     }
226     if( !subpk )
227         BUG();
228
229     /* and make the signature */
230     rc = make_keysig_packet( &sig, pk, NULL, subpk, sk, 0x18, 0,
231                                     keygen_add_key_expire, subpk );
232     if( rc ) {
233         log_error("make_keysig_packet failed: %s\n", gpg_errstr(rc) );
234         return rc;
235     }
236
237     pkt = gcry_xcalloc( 1, sizeof *pkt );
238     pkt->pkttype = PKT_SIGNATURE;
239     pkt->pkt.signature = sig;
240     add_kbnode( root, new_kbnode( pkt ) );
241     return rc;
242 }
243
244
245
246 static int
247 key_from_sexp( GCRY_MPI *array,
248                GCRY_SEXP sexp, const char *topname, const char *elems )
249 {
250     GCRY_SEXP list, l2;
251     const char *s;
252     int i, idx;
253
254     list = gcry_sexp_find_token( sexp, topname, 0 );
255     if( !list )
256         return GCRYERR_INV_OBJ;
257     l2 = gcry_sexp_cdr( list );
258     gcry_sexp_release ( list );
259     list = l2;
260     if( !list )
261         return GCRYERR_NO_OBJ;
262
263     idx = 0;
264     for(s=elems; *s; s++, idx++ ) {
265         l2 = gcry_sexp_find_token( list, s, 1 );
266         if( !l2 ) {
267             for(i=0; i<idx; i++) {
268                 gcry_free( array[i] );
269                 array[i] = NULL;
270             }
271             gcry_sexp_release ( list );
272             return GCRYERR_NO_OBJ; /* required parameter not found */
273         }
274         array[idx] = gcry_sexp_cdr_mpi( l2, GCRYMPI_FMT_USG );
275         gcry_sexp_release ( l2 );
276         if( !array[idx] ) {
277             for(i=0; i<idx; i++) {
278                 gcry_free( array[i] );
279                 array[i] = NULL;
280             }
281             gcry_sexp_release ( list );
282             return GCRYERR_INV_OBJ; /* required parameter is invalid */
283         }
284     }
285     gcry_sexp_release ( list );
286
287     return 0;
288 }
289
290
291 static int
292 factors_from_sexp( MPI **retarray, GCRY_SEXP sexp )
293 {
294     GCRY_SEXP list, l2;
295     size_t n;
296     int i;
297     GCRY_MPI *array;
298     void *ctx;
299
300     list = gcry_sexp_find_token( sexp, "misc-key-info", 0 );
301     if( !list )
302         return GCRYERR_INV_OBJ;
303     l2 = gcry_sexp_cdr( list );
304     gcry_sexp_release ( list );
305     list = l2;
306     if( !list )
307         return GCRYERR_NO_OBJ;
308     l2 = gcry_sexp_find_token( list, "pm1-factors", 0 );
309     gcry_sexp_release ( list );
310     list = l2;
311     if( !list )
312         return GCRYERR_NO_OBJ;
313
314     /* count factors */
315     ctx = NULL;
316     for( n=0; (l2 = gcry_sexp_enum( list, &ctx, 0 )); n++ )
317         gcry_sexp_release ( l2 );
318
319     array = gcry_xcalloc( n, sizeof *array );
320     if( !array ) {
321         gcry_sexp_release ( list );
322         return GCRYERR_NO_MEM;
323     }
324     /* retrieve factors */
325     ctx = NULL;
326     if( (l2 = gcry_sexp_enum( list, &ctx, 0 )) ) {
327         gcry_sexp_release ( l2 ); /* skip the car */
328         for( n=0; (l2 = gcry_sexp_enum( list, &ctx, 0 )); n++ ) {
329             array[n] = gcry_sexp_car_mpi( l2, 0 );
330             gcry_sexp_release ( l2 );
331             if( !array[n] ) {
332                 for(i=0; i < n; i++ )
333                     gcry_mpi_release( array[i] );
334                 gcry_free(array);
335                 gcry_sexp_release ( list );
336                 return GCRYERR_INV_OBJ;
337             }
338         }
339     }
340
341      gcry_sexp_release ( list );
342     *retarray = array;
343     return 0;
344 }
345
346
347
348 static int
349 gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
350         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
351 {
352     int rc;
353     int i;
354     PACKET *pkt;
355     PKT_secret_key *sk;
356     PKT_public_key *pk;
357     MPI *factors;
358     GCRY_SEXP s_parms, s_key;
359
360     assert( is_ELGAMAL(algo) );
361
362     if( nbits < 512 ) {
363         nbits = 1024;
364         log_info(_("keysize invalid; using %u bits\n"), nbits );
365     }
366
367     if( (nbits % 32) ) {
368         nbits = ((nbits + 31) / 32) * 32;
369         log_info(_("keysize rounded up to %u bits\n"), nbits );
370     }
371
372     if ( gcry_sexp_build ( &s_parms, NULL,
373                            "(genkey(%s(nbits %d)))",
374                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
375                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
376                            (int)nbits ) )
377         BUG ();
378
379     rc = gcry_pk_genkey( &s_key, s_parms );
380     gcry_sexp_release( s_parms );
381     if( rc ) {
382         log_error("pk_genkey failed: %s\n", gpg_errstr(rc) );
383         return rc;
384     }
385
386
387     sk = gcry_xcalloc( 1, sizeof *sk );
388     pk = gcry_xcalloc( 1, sizeof *pk );
389     sk->timestamp = pk->timestamp = make_timestamp();
390     sk->version = pk->version = 4;
391     if( expireval ) {
392         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
393     }
394     sk->pubkey_algo = pk->pubkey_algo = algo;
395
396     rc = key_from_sexp( pk->pkey, s_key, "public-key", "pgy" );
397     if( rc ) {
398         log_error("key_from_sexp failed: rc=%d\n", rc );
399         return rc;
400     }
401     rc = key_from_sexp( sk->skey, s_key, "private-key", "pgyx" );
402     if( rc ) {
403         log_error("key_from_sexp failed: rc=%d\n", rc );
404         return rc;
405     }
406     rc = factors_from_sexp( &factors, s_key );
407     if( rc ) {
408         log_error("factors_from_sexp failed: rc=%d\n", rc );
409         return rc;
410     }
411
412     sk->is_protected = 0;
413     sk->protect.algo = 0;
414
415     sk->csum = checksum_mpi( sk->skey[3] );
416     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
417         *ret_sk = copy_secret_key( NULL, sk );
418
419     if( dek ) {
420         sk->protect.algo = dek->algo;
421         sk->protect.s2k = *s2k;
422         rc = protect_secret_key( sk, dek );
423         if( rc ) {
424             log_error("protect_secret_key failed: %s\n", gpg_errstr(rc) );
425             free_public_key(pk);
426             free_secret_key(sk);
427             return rc;
428         }
429     }
430
431     pkt = gcry_xcalloc( 1,sizeof *pkt);
432     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
433     pkt->pkt.public_key = pk;
434     add_kbnode(pub_root, new_kbnode( pkt ));
435
436     /* don't know whether it makes sense to have the factors, so for now
437      * we store them in the secret keyring (but they are not secret) */
438     pkt = gcry_xcalloc( 1,sizeof *pkt);
439     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
440     pkt->pkt.secret_key = sk;
441     add_kbnode(sec_root, new_kbnode( pkt ));
442     for(i=0; factors[i]; i++ ) {
443         add_kbnode( sec_root,
444                     make_mpi_comment_node("#:ELG_factor:", factors[i] ));
445     }
446
447     return 0;
448 }
449
450
451 /****************
452  * Generate a DSA key
453  */
454 static int
455 gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
456             STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
457 {
458     int rc;
459     int i;
460     PACKET *pkt;
461     PKT_secret_key *sk;
462     PKT_public_key *pk;
463     MPI *factors;
464     GCRY_SEXP s_parms, s_key;
465
466     if( nbits > 1024 || nbits < 512 ) {
467         nbits = 1024;
468         log_info(_("keysize invalid; using %u bits\n"), nbits );
469     }
470
471     if( (nbits % 64) ) {
472         nbits = ((nbits + 63) / 64) * 64;
473         log_info(_("keysize rounded up to %u bits\n"), nbits );
474     }
475
476     if ( gcry_sexp_build ( &s_parms, NULL,
477                           "(genkey(dsa(nbits %d)))", (int)nbits ) )
478         BUG ();
479
480     rc = gcry_pk_genkey( &s_key, s_parms );
481     gcry_sexp_release( s_parms );
482     if( rc ) {
483         log_error("pk_genkey failed: %s\n", gpg_errstr(rc) );
484         return rc;
485     }
486
487
488     sk = gcry_xcalloc( 1, sizeof *sk );
489     pk = gcry_xcalloc( 1, sizeof *pk );
490     sk->timestamp = pk->timestamp = make_timestamp();
491     sk->version = pk->version = 4;
492     if( expireval ) {
493         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
494     }
495     sk->pubkey_algo = pk->pubkey_algo = GCRY_PK_DSA;
496
497     rc = key_from_sexp( pk->pkey, s_key, "public-key", "pqgy" );
498     if( rc ) {
499         log_error("key_from_sexp failed: rc=%d\n", rc );
500         return rc;
501     }
502     rc = key_from_sexp( sk->skey, s_key, "private-key", "pqgyx" );
503     if( rc ) {
504         log_error("key_from_sexp failed: rc=%d\n", rc );
505         return rc;
506     }
507     rc = factors_from_sexp( &factors, s_key );
508     if( rc ) {
509         log_error("factors_from_sexp failed: rc=%d\n", rc );
510         return rc;
511     }
512
513     sk->is_protected = 0;
514     sk->protect.algo = 0;
515
516     sk->csum = checksum_mpi( sk->skey[4] );
517     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
518         *ret_sk = copy_secret_key( NULL, sk );
519
520     if( dek ) {
521         sk->protect.algo = dek->algo;
522         sk->protect.s2k = *s2k;
523         rc = protect_secret_key( sk, dek );
524         if( rc ) {
525             log_error("protect_secret_key failed: %s\n", gpg_errstr(rc) );
526             free_public_key(pk);
527             free_secret_key(sk);
528             return rc;
529         }
530     }
531
532     pkt = gcry_xcalloc( 1,sizeof *pkt);
533     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
534     pkt->pkt.public_key = pk;
535     add_kbnode(pub_root, new_kbnode( pkt ));
536
537     /* don't know whether it makes sense to have the factors, so for now
538      * we store them in the secret keyring (but they are not secret)
539      * p = 2 * q * f1 * f2 * ... * fn
540      * We store only f1 to f_n-1;  fn can be calculated because p and q
541      * are known.
542      */
543     pkt = gcry_xcalloc( 1,sizeof *pkt);
544     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
545     pkt->pkt.secret_key = sk;
546     add_kbnode(sec_root, new_kbnode( pkt ));
547     for(i=1; factors[i]; i++ )  /* the first one is q */
548         add_kbnode( sec_root,
549                     make_mpi_comment_node("#:DSA_factor:", factors[i] ));
550
551     /* fixme: Merge this with the elg-generate function and release
552      * some more stuff (memory-leak) */
553     return 0;
554 }
555
556 #if 0
557 static int
558 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
559         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
560 {
561     int rc;
562     PACKET *pkt;
563     PKT_secret_key *sk;
564     PKT_public_key *pk;
565     MPI skey[4];
566     MPI *factors;
567
568     assert( is_RSA(algo) );
569
570     if( nbits < 1024 ) {
571         nbits = 1024;
572         log_info(_("keysize invalid; using %u bits\n"), nbits );
573     }
574
575     if( (nbits % 32) ) {
576         nbits = ((nbits + 31) / 32) * 32;
577         log_info(_("keysize rounded up to %u bits\n"), nbits );
578     }
579
580     rc = pubkey_generate( algo, nbits, skey, &factors );
581     if( rc ) {
582         log_error("pubkey_generate failed: %s\n", gpg_errstr(rc) );
583         return rc;
584     }
585
586     sk = gcry_xcalloc( 1, sizeof *sk );
587     pk = gcry_xcalloc( 1, sizeof *pk );
588     sk->timestamp = pk->timestamp = make_timestamp();
589     sk->version = pk->version = 4;
590     if( expireval ) {
591         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
592     }
593     sk->pubkey_algo = pk->pubkey_algo = algo;
594                        pk->pkey[0] = mpi_copy( skey[0] );
595                        pk->pkey[1] = mpi_copy( skey[1] );
596     sk->skey[0] = skey[0];
597     sk->skey[1] = skey[1];
598     sk->skey[2] = skey[2];
599     sk->skey[3] = skey[3];
600     sk->skey[4] = skey[4];
601     sk->skey[5] = skey[5];
602     sk->is_protected = 0;
603     sk->protect.algo = 0;
604
605     sk->csum  = checksum_mpi_counted_nbits( sk->skey[2] );
606     sk->csum += checksum_mpi_counted_nbits( sk->skey[3] );
607     sk->csum += checksum_mpi_counted_nbits( sk->skey[4] );
608     sk->csum += checksum_mpi_counted_nbits( sk->skey[5] );
609     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
610         *ret_sk = copy_secret_key( NULL, sk );
611
612     if( dek ) {
613         sk->protect.algo = dek->algo;
614         sk->protect.s2k = *s2k;
615         rc = protect_secret_key( sk, dek );
616         if( rc ) {
617             log_error("protect_secret_key failed: %s\n", gpg_errstr(rc) );
618             free_public_key(pk);
619             free_secret_key(sk);
620             return rc;
621         }
622     }
623
624     pkt = gcry_xcalloc( 1,sizeof *pkt);
625     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
626     pkt->pkt.public_key = pk;
627     add_kbnode(pub_root, new_kbnode( pkt ));
628
629     pkt = gcry_xcalloc( 1,sizeof *pkt);
630     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
631     pkt->pkt.secret_key = sk;
632     add_kbnode(sec_root, new_kbnode( pkt ));
633
634     return 0;
635 }
636 #endif
637
638
639 /****************
640  * check valid days:
641  * return 0 on error or the multiplier
642  */
643 static int
644 check_valid_days( const char *s )
645 {
646     if( !isdigit(*s) )
647         return 0;
648     for( s++; *s; s++)
649         if( !isdigit(*s) )
650             break;
651     if( !*s )
652         return 1;
653     if( s[1] )
654         return 0; /* e.g. "2323wc" */
655     if( *s == 'd' || *s == 'D' )
656         return 1;
657     if( *s == 'w' || *s == 'W' )
658         return 7;
659     if( *s == 'm' || *s == 'M' )
660         return 30;
661     if( *s == 'y' || *s == 'Y' )
662         return 365;
663     return 0;
664 }
665
666
667 /****************
668  * Returns: 0 to create both a DSA and a ElGamal key.
669  */
670 static int
671 ask_algo( int addmode )
672 {
673     char *answer;
674     int algo;
675
676     tty_printf(_("Please select what kind of key you want:\n"));
677     if( !addmode )
678         tty_printf(_("   (%d) DSA and ElGamal (default)\n"), 1 );
679     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
680     if( addmode )
681         tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
682     tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 4 );
683   #if 0
684     tty_printf(    _("   (%d) RSA (sign and encrypt)\n"), 5 );
685   #endif
686
687     for(;;) {
688         answer = cpr_get("keygen.algo",_("Your selection? "));
689         cpr_kill_prompt();
690         algo = *answer? atoi(answer): 1;
691         gcry_free(answer);
692         if( algo == 1 && !addmode ) {
693             algo = 0;   /* create both keys */
694             break;
695         }
696       #if 0
697         else if( algo == 5 ) {
698             if( cpr_get_answer_is_yes("keygen.algo.rsa_se",_(
699                 "Do you really want to create a sign and encrypt key? "))) {
700                 algo = GCRY_PK_RSA;
701                 break;
702             }
703         }
704       #endif
705         else if( algo == 4 ) {
706             if( cpr_get_answer_is_yes("keygen.algo.elg_se",_(
707                 "Do you really want to create a sign and encrypt key? "))) {
708                 algo = GCRY_PK_ELG;
709                 break;
710             }
711         }
712         else if( algo == 3 && addmode ) {
713             algo = GCRY_PK_ELG_E;
714             break;
715         }
716         else if( algo == 2 ) {
717             algo = GCRY_PK_DSA;
718             break;
719         }
720         else
721             tty_printf(_("Invalid selection.\n"));
722     }
723     return algo;
724 }
725
726
727 static unsigned
728 ask_keysize( int algo )
729 {
730     char *answer;
731     unsigned nbits;
732
733     tty_printf(_("About to generate a new %s keypair.\n"
734                  "              minimum keysize is  768 bits\n"
735                  "              default keysize is 1024 bits\n"
736                  "    highest suggested keysize is 2048 bits\n"),
737                                         gcry_pk_algo_name(algo) );
738     for(;;) {
739         answer = cpr_get("keygen.size",
740                           _("What keysize do you want? (1024) "));
741         cpr_kill_prompt();
742         nbits = *answer? atoi(answer): 1024;
743         gcry_free(answer);
744         if( algo == GCRY_PK_DSA && (nbits < 512 || nbits > 1024) )
745             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
746         else if( nbits < 768 )
747             tty_printf(_("keysize too small; 768 is smallest value allowed.\n"));
748         else if( algo == GCRY_PK_RSA && nbits < 1024 )
749             tty_printf(_("keysize too small;"
750                          " 1024 is smallest value allowed for RSA.\n"));
751         else if( nbits > 4096 ) {
752             /* It is ridiculous and an annoyance to use larger key sizes!
753              * GnuPG can handle much larger sizes; but it takes an eternity
754              * to create such a key (but less than the time the Sirius
755              * Computer Corporation needs to process one of the usual
756              * complaints) and {de,en}cryption although needs some time.
757              * So, before you complain about this limitation, I suggest that
758              * you start a discussion with Marvin about this theme and then
759              * do whatever you want. */
760             tty_printf(_("keysize too large; %d is largest value allowed.\n"),
761                                                                          4096);
762         }
763         else if( nbits > 2048 && !cpr_enabled() ) {
764             tty_printf(
765                 _("Keysizes larger than 2048 are not suggested because\n"
766                   "computations take REALLY long!\n"));
767             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
768                         "Are you sure that you want this keysize? ")) ) {
769                 tty_printf(_("Okay, but keep in mind that your monitor "
770                              "and keyboard radiation is also very vulnerable "
771                              "to attacks!\n"));
772                 break;
773             }
774         }
775         else if( nbits > 1536 && !cpr_enabled() && algo != GCRY_PK_RSA ) {
776             if( cpr_get_answer_is_yes("keygen.size.large.okay",_(
777                     "Do you really need such a large keysize? ")) )
778                 break;
779         }
780         else
781             break;
782     }
783     tty_printf(_("Requested keysize is %u bits\n"), nbits );
784     if( algo == GCRY_PK_DSA && (nbits % 64) ) {
785         nbits = ((nbits + 63) / 64) * 64;
786         tty_printf(_("rounded up to %u bits\n"), nbits );
787     }
788     else if( (nbits % 32) ) {
789         nbits = ((nbits + 31) / 32) * 32;
790         tty_printf(_("rounded up to %u bits\n"), nbits );
791     }
792     return nbits;
793 }
794
795
796 /****************
797  * Parse an expire string and return it's value in days.
798  * Returns -1 on error.
799  */
800 static int
801 parse_expire_string( const char *string )
802 {
803     int mult;
804     u32 abs_date=0;
805     u32 curtime = make_timestamp();
806     int valid_days;
807
808     if( !*string )
809         valid_days = 0;
810     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
811         /* This calculation is not perfectly okay because we
812          * are later going to simply multiply by 86400 and don't
813          * correct for leapseconds.  A solution would be to change
814          * the whole implemenation to work with dates and not intervals
815          * which are required for v3 keys.
816          */
817         valid_days = abs_date/86400-curtime/86400+1;
818     }
819     else if( (mult=check_valid_days(string)) ) {
820         valid_days = atoi(string) * mult;
821         if( valid_days < 0 || valid_days > 39447 )
822             valid_days = 0;
823     }
824     else {
825         valid_days = -1;
826     }
827     return valid_days;
828 }
829
830
831 static u32
832 ask_expire_interval(void)
833 {
834     char *answer;
835     int valid_days=0;
836     u32 interval = 0;
837
838     tty_printf(_("Please specify how long the key should be valid.\n"
839                  "         0 = key does not expire\n"
840                  "      <n>  = key expires in n days\n"
841                  "      <n>w = key expires in n weeks\n"
842                  "      <n>m = key expires in n months\n"
843                  "      <n>y = key expires in n years\n"));
844     /* Note: The elgamal subkey for DSA has no expiration date because
845      * it must be signed with the DSA key and this one has the expiration
846      * date */
847
848     answer = NULL;
849     for(;;) {
850         u32 curtime=make_timestamp();
851
852         gcry_free(answer);
853         answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
854         cpr_kill_prompt();
855         trim_spaces(answer);
856         valid_days = parse_expire_string( answer );
857         if( valid_days < 0 ) {
858             tty_printf(_("invalid value\n"));
859             continue;
860         }
861
862         if( !valid_days ) {
863             tty_printf(_("Key does not expire at all\n"));
864             interval = 0;
865         }
866         else {
867             interval = valid_days * 86400L;
868             /* print the date when the key expires */
869             tty_printf(_("Key expires at %s\n"),
870                         asctimestamp((ulong)(curtime + interval) ) );
871             if( (time_t)((ulong)(curtime+interval)) < 0 )
872                 tty_printf(_("Your system can't display dates beyond 2038.\n"
873                     "However, it will be correctly handled up to 2106.\n"));
874         }
875
876         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
877                                             _("Is this correct (y/n)? ")) )
878             break;
879     }
880     gcry_free(answer);
881     return interval;
882 }
883
884 u32
885 ask_expiredate()
886 {
887     u32 x = ask_expire_interval();
888     return x? make_timestamp() + x : 0;
889 }
890
891 static int
892 has_invalid_email_chars( const char *s )
893 {
894     int at_seen=0;
895     static char valid_chars[] = "01234567890_-."
896                                 "abcdefghijklmnopqrstuvwxyz"
897                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
898
899     for( ; *s; s++ ) {
900         if( *s & 0x80 )
901             return 1;
902         if( *s == '@' )
903             at_seen=1;
904         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
905             return 1;
906         else if( at_seen && !strchr( valid_chars, *s ) )
907             return 1;
908     }
909     return 0;
910 }
911
912
913 static char *
914 ask_user_id( int mode )
915 {
916     char *answer;
917     char *aname, *acomment, *amail, *uid;
918
919     if( !mode )
920         tty_printf( _("\n"
921 "You need a User-ID to identify your key; the software constructs the user id\n"
922 "from Real Name, Comment and Email Address in this form:\n"
923 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
924     uid = aname = acomment = amail = NULL;
925     for(;;) {
926         char *p;
927         int fail=0;
928
929         if( !aname ) {
930             for(;;) {
931                 gcry_free(aname);
932                 aname = cpr_get("keygen.name",_("Real name: "));
933                 trim_spaces(aname);
934                 cpr_kill_prompt();
935                 if( strpbrk( aname, "<([])>" ) )
936                     tty_printf(_("Invalid character in name\n"));
937                 else if( isdigit(*aname) )
938                     tty_printf(_("Name may not start with a digit\n"));
939                 else if( strlen(aname) < 5 )
940                     tty_printf(_("Name must be at least 5 characters long\n"));
941                 else
942                     break;
943             }
944         }
945         if( !amail ) {
946             for(;;) {
947                 gcry_free(amail);
948                 amail = cpr_get("keygen.email",_("Email address: "));
949                 trim_spaces(amail);
950                 cpr_kill_prompt();
951                 if( !*amail )
952                     break;   /* no email address is okay */
953                 else if( has_invalid_email_chars(amail)
954                          || string_count_chr(amail,'@') != 1
955                          || *amail == '@'
956                          || amail[strlen(amail)-1] == '@'
957                          || amail[strlen(amail)-1] == '.'
958                          || strstr(amail, "..") )
959                     tty_printf(_("Not a valid email address\n"));
960                 else
961                     break;
962             }
963         }
964         if( !acomment ) {
965             for(;;) {
966                 gcry_free(acomment);
967                 acomment = cpr_get("keygen.comment",_("Comment: "));
968                 trim_spaces(acomment);
969                 cpr_kill_prompt();
970                 if( !*acomment )
971                     break;   /* no comment is okay */
972                 else if( strpbrk( acomment, "()" ) )
973                     tty_printf(_("Invalid character in comment\n"));
974                 else
975                     break;
976             }
977         }
978
979
980         gcry_free(uid);
981         uid = p = gcry_xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
982         p = stpcpy(p, aname );
983         if( *acomment )
984             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
985         if( *amail )
986             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
987
988         /* append a warning if we do not have dev/random
989          * or it is switched into  quick testmode */
990         #warning quick_random_gen() not available
991       #if 0
992         if( quick_random_gen(-1) )
993             strcpy(p, " (INSECURE!)" );
994       #endif
995
996         /* print a note in case that UTF8 mapping has to be done */
997         for(p=uid; *p; p++ ) {
998             if( *p & 0x80 ) {
999                 tty_printf(_("You are using the `%s' character set.\n"),
1000                            get_native_charset() );
1001                 break;
1002             }
1003         }
1004
1005         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1006         /* fixme: add a warning if this user-id already exists */
1007         if( !*amail && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1008             fail = 1;
1009             tty_printf(_("Please don't put the email address "
1010                           "into the real name or the comment\n") );
1011         }
1012
1013         for(;;) {
1014             char *ansstr = _("NnCcEeOoQq");
1015
1016             if( strlen(ansstr) != 10 )
1017                 BUG();
1018             if( cpr_enabled() ) {
1019                 answer = gcry_xstrdup(ansstr+6);
1020                 answer[1] = 0;
1021             }
1022             else {
1023                 answer = cpr_get("keygen.userid.cmd", fail?
1024                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1025                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1026                 cpr_kill_prompt();
1027             }
1028             if( strlen(answer) > 1 )
1029                 ;
1030             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1031                 gcry_free(aname); aname = NULL;
1032                 break;
1033             }
1034             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1035                 gcry_free(acomment); acomment = NULL;
1036                 break;
1037             }
1038             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1039                 gcry_free(amail); amail = NULL;
1040                 break;
1041             }
1042             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1043                 if( fail ) {
1044                     tty_printf(_("Please correct the error first\n"));
1045                 }
1046                 else {
1047                     gcry_free(aname); aname = NULL;
1048                     gcry_free(acomment); acomment = NULL;
1049                     gcry_free(amail); amail = NULL;
1050                     break;
1051                 }
1052             }
1053             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1054                 gcry_free(aname); aname = NULL;
1055                 gcry_free(acomment); acomment = NULL;
1056                 gcry_free(amail); amail = NULL;
1057                 gcry_free(uid); uid = NULL;
1058                 break;
1059             }
1060             gcry_free(answer);
1061         }
1062         gcry_free(answer);
1063         if( !amail && !acomment && !amail )
1064             break;
1065         gcry_free(uid); uid = NULL;
1066     }
1067     if( uid ) {
1068         char *p = native_to_utf8( uid );
1069         gcry_free( uid );
1070         uid = p;
1071     }
1072     return uid;
1073 }
1074
1075
1076 static DEK *
1077 ask_passphrase( STRING2KEY **ret_s2k )
1078 {
1079     DEK *dek = NULL;
1080     STRING2KEY *s2k;
1081
1082     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1083
1084     s2k = gcry_xmalloc_secure( sizeof *s2k );
1085     for(;;) {
1086         s2k->mode = opt.s2k_mode;
1087         s2k->hash_algo = opt.s2k_digest_algo;
1088         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2 );
1089         if( !dek ) {
1090             tty_printf(_("passphrase not correctly repeated; try again.\n"));
1091         }
1092         else if( !dek->keylen ) {
1093             gcry_free(dek); dek = NULL;
1094             gcry_free(s2k); s2k = NULL;
1095             tty_printf(_(
1096             "You don't want a passphrase - this is probably a *bad* idea!\n"
1097             "I will do it anyway.  You can change your passphrase at any time,\n"
1098             "using this program with the option \"--edit-key\".\n\n"));
1099             break;
1100         }
1101         else
1102             break; /* okay */
1103     }
1104     *ret_s2k = s2k;
1105     return dek;
1106 }
1107
1108
1109 static int
1110 do_create( int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root,
1111            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate )
1112 {
1113     int rc=0;
1114
1115     if( !opt.batch )
1116         tty_printf(_(
1117 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1118 "some other action (type on the keyboard, move the mouse, utilize the\n"
1119 "disks) during the prime generation; this gives the random number\n"
1120 "generator a better chance to gain enough entropy.\n") );
1121
1122     if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E )
1123         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1124     else if( algo == GCRY_PK_DSA )
1125         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1126   #if 0
1127     else if( algo == GCRY_PK_RSA )
1128         rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1129   #endif
1130     else
1131         BUG();
1132
1133   #ifdef ENABLE_COMMENT_PACKETS
1134     if( !rc ) {
1135         add_kbnode( pub_root,
1136                 make_comment_node("#created by GNUPG v" VERSION " ("
1137                                             PRINTABLE_OS_NAME ")"));
1138         add_kbnode( sec_root,
1139                 make_comment_node("#created by GNUPG v" VERSION " ("
1140                                             PRINTABLE_OS_NAME ")"));
1141     }
1142   #endif
1143     return rc;
1144 }
1145
1146
1147 /****************
1148  * Generate a new user id packet, or return NULL if canceled
1149  */
1150 PKT_user_id *
1151 generate_user_id()
1152 {
1153     PKT_user_id *uid;
1154     char *p;
1155     size_t n;
1156
1157     p = ask_user_id( 1 );
1158     if( !p )
1159         return NULL;
1160     n = strlen(p);
1161     uid = gcry_xcalloc( 1, sizeof *uid + n - 1 );
1162     uid->len = n;
1163     strcpy(uid->name, p);
1164     return uid;
1165 }
1166
1167
1168 static void
1169 release_parameter_list( struct para_data_s *r )
1170 {
1171     struct para_data_s *r2;
1172
1173     for( ; r ; r = r2 ) {
1174         r2 = r->next;
1175         if( r->key == pPASSPHRASE_DEK )
1176             gcry_free( r->u.dek );
1177         else if( r->key == pPASSPHRASE_S2K )
1178             gcry_free( r->u.s2k );
1179
1180         gcry_free(r);
1181     }
1182 }
1183
1184 static struct para_data_s *
1185 get_parameter( struct para_data_s *para, enum para_name key )
1186 {
1187     struct para_data_s *r;
1188
1189     for( r = para; r && r->key != key; r = r->next )
1190         ;
1191     return r;
1192 }
1193
1194 static const char *
1195 get_parameter_value( struct para_data_s *para, enum para_name key )
1196 {
1197     struct para_data_s *r = get_parameter( para, key );
1198     return (r && *r->u.value)? r->u.value : NULL;
1199 }
1200
1201 static int
1202 get_parameter_algo( struct para_data_s *para, enum para_name key )
1203 {
1204     struct para_data_s *r = get_parameter( para, key );
1205     if( !r )
1206         return -1;
1207     if( isdigit( *r->u.value ) )
1208         return atoi( r->u.value );
1209     return gcry_pk_map_name( r->u.value );
1210 }
1211
1212
1213 static u32
1214 get_parameter_u32( struct para_data_s *para, enum para_name key )
1215 {
1216     struct para_data_s *r = get_parameter( para, key );
1217
1218     if( !r )
1219         return 0;
1220     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1221         return r->u.expire;
1222
1223     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1224 }
1225
1226 static unsigned int
1227 get_parameter_uint( struct para_data_s *para, enum para_name key )
1228 {
1229     return get_parameter_u32( para, key );
1230 }
1231
1232 static DEK *
1233 get_parameter_dek( struct para_data_s *para, enum para_name key )
1234 {
1235     struct para_data_s *r = get_parameter( para, key );
1236     return r? r->u.dek : NULL;
1237 }
1238
1239 static STRING2KEY *
1240 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1241 {
1242     struct para_data_s *r = get_parameter( para, key );
1243     return r? r->u.s2k : NULL;
1244 }
1245
1246
1247 static int
1248 proc_parameter_file( struct para_data_s *para, const char *fname,
1249                                        struct output_control_s *outctrl )
1250 {
1251     struct para_data_s *r;
1252     const char *s1, *s2, *s3;
1253     size_t n;
1254     char *p;
1255     int i;
1256
1257     /* check that we have all required parameters */
1258     assert( get_parameter( para, pKEYTYPE ) );
1259     i = get_parameter_algo( para, pKEYTYPE );
1260     if( i < 1 || openpgp_pk_test_algo( i, GCRY_PK_USAGE_SIGN ) ) {
1261         r = get_parameter( para, pKEYTYPE );
1262         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1263         return -1;
1264     }
1265
1266     i = get_parameter_algo( para, pSUBKEYTYPE );
1267     if( i > 1 && openpgp_pk_test_algo( i, 0 ) ) {
1268         r = get_parameter( para, pSUBKEYTYPE );
1269         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1270         return -1;
1271     }
1272
1273     if( !get_parameter_value( para, pUSERID ) ) {
1274         /* create the formatted user ID */
1275         s1 = get_parameter_value( para, pNAMEREAL );
1276         s2 = get_parameter_value( para, pNAMECOMMENT );
1277         s3 = get_parameter_value( para, pNAMEEMAIL );
1278         if( s1 || s2 || s3 ) {
1279             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1280             r = gcry_xcalloc( 1, sizeof *r + n + 20 );
1281             r->key = pUSERID;
1282             p = r->u.value;
1283             if( s1 )
1284                 p = stpcpy(p, s1 );
1285             if( s2 )
1286                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1287             if( s3 )
1288                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1289             r->next = para;
1290             para = r;
1291         }
1292     }
1293
1294     /* make DEK and S2K from the Passphrase */
1295     r = get_parameter( para, pPASSPHRASE );
1296     if( r && *r->u.value ) {
1297         /* we have a plain text passphrase - create a DEK from it.
1298          * It is a little bit ridiculous to keep it ih secure memory
1299          * but becuase we do this alwasy, why not here */
1300         STRING2KEY *s2k;
1301         DEK *dek;
1302
1303         s2k = gcry_xmalloc_secure( sizeof *s2k );
1304         s2k->mode = opt.s2k_mode;
1305         s2k->hash_algo = opt.s2k_digest_algo;
1306         set_next_passphrase( r->u.value );
1307         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2 );
1308         set_next_passphrase( NULL );
1309         assert( dek );
1310         memset( r->u.value, 0, strlen(r->u.value) );
1311
1312         r = gcry_xcalloc( 1, sizeof *r );
1313         r->key = pPASSPHRASE_S2K;
1314         r->u.s2k = s2k;
1315         r->next = para;
1316         para = r;
1317         r = gcry_xcalloc( 1, sizeof *r );
1318         r->key = pPASSPHRASE_DEK;
1319         r->u.dek = dek;
1320         r->next = para;
1321         para = r;
1322     }
1323
1324     /* make KEYEXPIRE from Expire-Date */
1325     r = get_parameter( para, pEXPIREDATE );
1326     if( r && *r->u.value ) {
1327         i = parse_expire_string( r->u.value );
1328         if( i < 0 ) {
1329             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1330             return -1;
1331         }
1332         r->u.expire = i * 86400L;
1333         r->key = pKEYEXPIRE;  /* change hat entry */
1334         /* also set it for the subkey */
1335         r = gcry_xcalloc( 1, sizeof *r + 20 );
1336         r->key = pSUBKEYEXPIRE;
1337         r->u.expire = i * 86400L;
1338         r->next = para;
1339         para = r;
1340     }
1341
1342     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
1343         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
1344         return -1;
1345     }
1346
1347     do_generate_keypair( para, outctrl );
1348     return 0;
1349 }
1350
1351
1352 /****************
1353  * Kludge to allow non interactive key generation controlled
1354  * by a parameter file (which currently is only stdin)
1355  * Note, that string parameters are expected to be in UTF-8
1356  */
1357 static void
1358 read_parameter_file( const char *fname )
1359 {
1360     static struct { const char *name;
1361                     enum para_name key;
1362     } keywords[] = {
1363         { "Key-Type",       pKEYTYPE},
1364         { "Key-Length",     pKEYLENGTH },
1365         { "Subkey-Type",    pSUBKEYTYPE },
1366         { "Subkey-Length",  pSUBKEYLENGTH },
1367         { "Name-Real",      pNAMEREAL },
1368         { "Name-Email",     pNAMEEMAIL },
1369         { "Name-Comment",   pNAMECOMMENT },
1370         { "Expire-Date",    pEXPIREDATE },
1371         { "Passphrase",     pPASSPHRASE },
1372         { NULL, 0 }
1373     };
1374     FILE *fp;
1375     char line[1024], *p;
1376     int lnr;
1377     const char *err = NULL;
1378     struct para_data_s *para, *r;
1379     int i;
1380     struct output_control_s outctrl;
1381
1382     memset( &outctrl, 0, sizeof( outctrl ) );
1383
1384     if( !fname || !*fname || !strcmp(fname,"-") ) {
1385         fp = stdin;
1386         fname = "-";
1387     }
1388     else {
1389         fp = fopen( fname, "r" );
1390         if( !fp ) {
1391             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
1392             return;
1393         }
1394     }
1395
1396     lnr = 0;
1397     err = NULL;
1398     para = NULL;
1399     while( fgets( line, DIM(line)-1, fp ) ) {
1400         char *keyword, *value;
1401
1402         lnr++;
1403         if( *line && line[strlen(line)-1] != '\n' ) {
1404             err = "line too long";
1405             break;
1406         }
1407         for( p = line; isspace(*p); p++ )
1408             ;
1409         if( !*p || *p == '#' )
1410             continue;
1411         keyword = p;
1412         if( *keyword == '%' ) {
1413             for( ; !isspace(*p); p++ )
1414                 ;
1415             if( *p )
1416                 *p++ = 0;
1417             for( ; isspace(*p); p++ )
1418                 ;
1419             value = p;
1420             trim_trailing_ws( value, strlen(value) );
1421             if( !stricmp( keyword, "%echo" ) )
1422                 log_info("%s\n", value );
1423             else if( !stricmp( keyword, "%dry-run" ) )
1424                 outctrl.dryrun = 1;
1425             else if( !stricmp( keyword, "%commit" ) ) {
1426                 outctrl.lnr = lnr;
1427                 proc_parameter_file( para, fname, &outctrl );
1428                 release_parameter_list( para );
1429                 para = NULL;
1430             }
1431             else if( !stricmp( keyword, "%pubring" ) ) {
1432                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
1433                     ; /* still the same file - ignore it */
1434                 else {
1435                     gcry_free( outctrl.pub.newfname );
1436                     outctrl.pub.newfname = gcry_xstrdup( value );
1437                     outctrl.use_files = 1;
1438                 }
1439             }
1440             else if( !stricmp( keyword, "%secring" ) ) {
1441                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
1442                     ; /* still the same file - ignore it */
1443                 else {
1444                    gcry_free( outctrl.sec.newfname );
1445                    outctrl.sec.newfname = gcry_xstrdup( value );
1446                    outctrl.use_files = 1;
1447                 }
1448             }
1449             else
1450                 log_info("skipping control `%s' (%s)\n", keyword, value );
1451
1452
1453             continue;
1454         }
1455
1456
1457         if( !(p = strchr( p, ':' )) || p == keyword ) {
1458             err = "missing colon";
1459             break;
1460         }
1461         if( *p )
1462             *p++ = 0;
1463         for( ; isspace(*p); p++ )
1464             ;
1465         if( !*p ) {
1466             err = "missing argument";
1467             break;
1468         }
1469         value = p;
1470         trim_trailing_ws( value, strlen(value) );
1471
1472         for(i=0; keywords[i].name; i++ ) {
1473             if( !stricmp( keywords[i].name, keyword ) )
1474                 break;
1475         }
1476         if( !keywords[i].name ) {
1477             err = "unknown keyword";
1478             break;
1479         }
1480         if( keywords[i].key != pKEYTYPE && !para ) {
1481             err = "parameter block does not start with \"Key-Type\"";
1482             break;
1483         }
1484
1485         if( keywords[i].key == pKEYTYPE && para ) {
1486             outctrl.lnr = lnr;
1487             proc_parameter_file( para, fname, &outctrl );
1488             release_parameter_list( para );
1489             para = NULL;
1490         }
1491         else {
1492             for( r = para; r; r = r->next ) {
1493                 if( r->key == keywords[i].key )
1494                     break;
1495             }
1496             if( r ) {
1497                 err = "duplicate keyword";
1498                 break;
1499             }
1500         }
1501         r = gcry_xcalloc( 1, sizeof *r + strlen( value ) );
1502         r->lnr = lnr;
1503         r->key = keywords[i].key;
1504         strcpy( r->u.value, value );
1505         r->next = para;
1506         para = r;
1507     }
1508     if( err )
1509         log_error("%s:%d: %s\n", fname, lnr, err );
1510     else if( ferror(fp) ) {
1511         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
1512     }
1513     else if( para ) {
1514         outctrl.lnr = lnr;
1515         proc_parameter_file( para, fname, &outctrl );
1516     }
1517
1518     if( outctrl.use_files ) { /* close open streams */
1519         iobuf_close( outctrl.pub.stream );
1520         iobuf_close( outctrl.sec.stream );
1521         gcry_free( outctrl.pub.fname );
1522         gcry_free( outctrl.pub.newfname );
1523         gcry_free( outctrl.sec.fname );
1524         gcry_free( outctrl.sec.newfname );
1525     }
1526
1527     release_parameter_list( para );
1528     if( strcmp( fname, "-" ) )
1529         fclose(fp);
1530 }
1531
1532
1533 /****************
1534  * Generate a keypair
1535  * (fname is only used in batch mode)
1536  */
1537 void
1538 generate_keypair( const char *fname )
1539 {
1540     unsigned int nbits;
1541     char *uid = NULL;
1542     DEK *dek;
1543     STRING2KEY *s2k;
1544     int algo;
1545     int both = 0;
1546     u32 expire;
1547     struct para_data_s *para = NULL;
1548     struct para_data_s *r;
1549     struct output_control_s outctrl;
1550
1551     memset( &outctrl, 0, sizeof( outctrl ) );
1552
1553     if( opt.batch ) {
1554         read_parameter_file( fname );
1555         return;
1556     }
1557
1558     algo = ask_algo( 0 );
1559     if( !algo ) { /* default: DSA with ElG subkey of the specified size */
1560         both = 1;
1561         r = gcry_xcalloc( 1, sizeof *r + 20 );
1562         r->key = pKEYTYPE;
1563         sprintf( r->u.value, "%d", GCRY_PK_DSA );
1564         r->next = para;
1565         para = r;
1566         tty_printf(_("DSA keypair will have 1024 bits.\n"));
1567         r = gcry_xcalloc( 1, sizeof *r + 20 );
1568         r->key = pKEYLENGTH;
1569         strcpy( r->u.value, "1024" );
1570         r->next = para;
1571         para = r;
1572
1573         algo = GCRY_PK_ELG_E;
1574         r = gcry_xcalloc( 1, sizeof *r + 20 );
1575         r->key = pSUBKEYTYPE;
1576         sprintf( r->u.value, "%d", algo );
1577         r->next = para;
1578         para = r;
1579     }
1580     else {
1581         r = gcry_xcalloc( 1, sizeof *r + 20 );
1582         r->key = pKEYTYPE;
1583         sprintf( r->u.value, "%d", algo );
1584         r->next = para;
1585         para = r;
1586     }
1587
1588     nbits = ask_keysize( algo );
1589     r = gcry_xcalloc( 1, sizeof *r + 20 );
1590     r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
1591     sprintf( r->u.value, "%u", nbits);
1592     r->next = para;
1593     para = r;
1594
1595     expire = ask_expire_interval();
1596     r = gcry_xcalloc( 1, sizeof *r + 20 );
1597     r->key = pKEYEXPIRE;
1598     r->u.expire = expire;
1599     r->next = para;
1600     para = r;
1601     r = gcry_xcalloc( 1, sizeof *r + 20 );
1602     r->key = pSUBKEYEXPIRE;
1603     r->u.expire = expire;
1604     r->next = para;
1605     para = r;
1606
1607     uid = ask_user_id(0);
1608     if( !uid ) {
1609         log_error(_("Key generation canceled.\n"));
1610         release_parameter_list( para );
1611         return;
1612     }
1613     r = gcry_xcalloc( 1, sizeof *r + strlen(uid) );
1614     r->key = pUSERID;
1615     strcpy( r->u.value, uid );
1616     r->next = para;
1617     para = r;
1618
1619     dek = ask_passphrase( &s2k );
1620     if( dek ) {
1621         r = gcry_xcalloc( 1, sizeof *r );
1622         r->key = pPASSPHRASE_DEK;
1623         r->u.dek = dek;
1624         r->next = para;
1625         para = r;
1626         r = gcry_xcalloc( 1, sizeof *r );
1627         r->key = pPASSPHRASE_S2K;
1628         r->u.s2k = s2k;
1629         r->next = para;
1630         para = r;
1631     }
1632
1633     proc_parameter_file( para, "[internal]", &outctrl );
1634     release_parameter_list( para );
1635 }
1636
1637
1638 static void
1639 do_generate_keypair( struct para_data_s *para,
1640                      struct output_control_s *outctrl )
1641 {
1642     char *pub_fname = NULL;
1643     char *sec_fname = NULL;
1644     KBNODE pub_root = NULL;
1645     KBNODE sec_root = NULL;
1646     PKT_secret_key *sk = NULL;
1647     const char *s;
1648     int rc;
1649
1650     if( outctrl->dryrun ) {
1651         log_info("dry-run mode - key generation skipped\n");
1652         return;
1653     }
1654
1655
1656     if( outctrl->use_files ) {
1657         if( outctrl->pub.newfname ) {
1658             iobuf_close(outctrl->pub.stream);
1659             outctrl->pub.stream = NULL;
1660             gcry_free( outctrl->pub.fname );
1661             outctrl->pub.fname =  outctrl->pub.newfname;
1662             outctrl->pub.newfname = NULL;
1663
1664             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
1665             if( !outctrl->pub.stream ) {
1666                 log_error("can't create `%s': %s\n", outctrl->pub.newfname,
1667                                                      strerror(errno) );
1668                 return;
1669             }
1670             if( opt.armor ) {
1671                 outctrl->pub.afx.what = 1;
1672                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
1673                                                     &outctrl->pub.afx );
1674             }
1675         }
1676         if( outctrl->sec.newfname ) {
1677             iobuf_close(outctrl->sec.stream);
1678             outctrl->sec.stream = NULL;
1679             gcry_free( outctrl->sec.fname );
1680             outctrl->sec.fname =  outctrl->sec.newfname;
1681             outctrl->sec.newfname = NULL;
1682
1683             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
1684             if( !outctrl->sec.stream ) {
1685                 log_error("can't create `%s': %s\n", outctrl->sec.newfname,
1686                                                      strerror(errno) );
1687                 return;
1688             }
1689             if( opt.armor ) {
1690                 outctrl->sec.afx.what = 5;
1691                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
1692                                                     &outctrl->sec.afx );
1693             }
1694         }
1695         pub_fname = outctrl->pub.fname; /* only for info output */
1696         sec_fname = outctrl->sec.fname; /* only for info output */
1697         assert( outctrl->pub.stream );
1698         assert( outctrl->sec.stream );
1699     }
1700     else {
1701         pub_fname = get_writable_keyblock_file( 0 );
1702         sec_fname = get_writable_keyblock_file( 1 );
1703     }
1704
1705     if( opt.verbose ) {
1706         log_info(_("writing public key to `%s'\n"), pub_fname );
1707         log_info(_("writing secret key to `%s'\n"), sec_fname );
1708     }
1709
1710     /* we create the packets as a tree of kbnodes. Because the structure
1711      * we create is known in advance we simply generate a linked list
1712      * The first packet is a dummy comment packet which we flag
1713      * as deleted.  The very first packet must always be a KEY packet.
1714      */
1715     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
1716     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
1717
1718     rc = do_create( get_parameter_algo( para, pKEYTYPE ),
1719                     get_parameter_uint( para, pKEYLENGTH ),
1720                     pub_root, sec_root,
1721                     get_parameter_dek( para, pPASSPHRASE_DEK ),
1722                     get_parameter_s2k( para, pPASSPHRASE_S2K ),
1723                     &sk,
1724                     get_parameter_u32( para, pKEYEXPIRE ) );
1725     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
1726         write_uid(pub_root, s );
1727         if( !rc )
1728             write_uid(sec_root, s );
1729         if( !rc )
1730             rc = write_selfsig(pub_root, pub_root, sk);
1731         if( !rc )
1732             rc = write_selfsig(sec_root, pub_root, sk);
1733     }
1734
1735     if( get_parameter( para, pSUBKEYTYPE ) ) {
1736         rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
1737                         get_parameter_uint( para, pSUBKEYLENGTH ),
1738                         pub_root, sec_root,
1739                         get_parameter_dek( para, pPASSPHRASE_DEK ),
1740                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
1741                         NULL,
1742                         get_parameter_u32( para, pSUBKEYEXPIRE ) );
1743         if( !rc )
1744             rc = write_keybinding(pub_root, pub_root, sk);
1745         if( !rc )
1746             rc = write_keybinding(sec_root, pub_root, sk);
1747     }
1748
1749
1750     if( !rc && outctrl->use_files ) { /* direct write to specified files */
1751         rc = write_keyblock( outctrl->pub.stream, pub_root );
1752         if( rc )
1753             log_error("can't write public key: %s\n", gpg_errstr(rc) );
1754         if( !rc ) {
1755             rc = write_keyblock( outctrl->sec.stream, sec_root );
1756             if( rc )
1757                 log_error("can't write secret key: %s\n", gpg_errstr(rc) );
1758         }
1759
1760     }
1761     else if( !rc ) { /* write to the standard keyrings */
1762         KBPOS pub_kbpos;
1763         KBPOS sec_kbpos;
1764         int rc1 = -1;
1765         int rc2 = -1;
1766
1767         /* we can now write the certificates */
1768         if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
1769             if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
1770                 log_error("can add keyblock file `%s'\n", pub_fname );
1771                 rc = GPGERR_CREATE_FILE;
1772             }
1773             else if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
1774                 log_error("can get keyblock handle for `%s'\n", pub_fname );
1775                 rc = GPGERR_CREATE_FILE;
1776             }
1777         }
1778         if( rc )
1779             ;
1780         else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
1781             if( add_keyblock_resource( sec_fname, 1, 1 ) ) {
1782                 log_error("can add keyblock file `%s'\n", sec_fname );
1783                 rc = GPGERR_CREATE_FILE;
1784             }
1785             else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
1786                 log_error("can get keyblock handle for `%s'\n", sec_fname );
1787                 rc = GPGERR_CREATE_FILE;
1788             }
1789         }
1790
1791         if( rc )
1792             ;
1793         else if( (rc=rc1=lock_keyblock( &pub_kbpos )) )
1794             log_error("can't lock public keyring: %s\n", gpg_errstr(rc) );
1795         else if( (rc=rc2=lock_keyblock( &sec_kbpos )) )
1796             log_error("can't lock secret keyring: %s\n", gpg_errstr(rc) );
1797         else if( (rc=insert_keyblock( &pub_kbpos, pub_root )) )
1798             log_error("can't write public key: %s\n", gpg_errstr(rc) );
1799         else if( (rc=insert_keyblock( &sec_kbpos, sec_root )) )
1800             log_error("can't write secret key: %s\n", gpg_errstr(rc) );
1801         else {
1802             if( !opt.batch )
1803                  tty_printf(_("public and secret key created and signed.\n") );
1804             if( !opt.batch
1805                 && get_parameter_algo( para, pKEYTYPE ) == GCRY_PK_DSA
1806                 && !get_parameter( para, pSUBKEYTYPE ) )
1807             {
1808                 tty_printf(_("Note that this key cannot be used for "
1809                              "encryption.  You may want to use\n"
1810                              "the command \"--edit-key\" to generate a "
1811                              "secondary key for this purpose.\n") );
1812             }
1813         }
1814
1815         if( !rc1 )
1816             unlock_keyblock( &pub_kbpos );
1817         if( !rc2 )
1818             unlock_keyblock( &sec_kbpos );
1819     }
1820
1821     if( rc ) {
1822         if( opt.batch )
1823             log_error("key generation failed: %s\n", gpg_errstr(rc) );
1824         else
1825             tty_printf(_("Key generation failed: %s\n"), gpg_errstr(rc) );
1826     }
1827     release_kbnode( pub_root );
1828     release_kbnode( sec_root );
1829     if( sk ) /* the unprotected  secret key */
1830         free_secret_key(sk);
1831     if( !outctrl->use_files ) {
1832         gcry_free(pub_fname);
1833         gcry_free(sec_fname);
1834     }
1835 }
1836
1837
1838 /****************
1839  * add a new subkey to an existing key.
1840  * Returns true if a new key has been generated and put into the keyblocks.
1841  */
1842 int
1843 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
1844 {
1845     int okay=0, rc=0;
1846     KBNODE node;
1847     PKT_secret_key *sk = NULL; /* this is the primary sk */
1848     int algo;
1849     u32 expire;
1850     unsigned nbits;
1851     char *passphrase = NULL;
1852     DEK *dek = NULL;
1853     STRING2KEY *s2k = NULL;
1854     u32 cur_time;
1855
1856     /* break out the primary secret key */
1857     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
1858     if( !node ) {
1859         log_error("Oops; secret key not found anymore!\n");
1860         goto leave;
1861     }
1862
1863     /* make a copy of the sk to keep the protected one in the keyblock */
1864     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
1865
1866     cur_time = make_timestamp();
1867     if( sk->timestamp > cur_time ) {
1868         ulong d = sk->timestamp - cur_time;
1869         log_info( d==1 ? _("key has been created %lu second "
1870                            "in future (time warp or clock problem)\n")
1871                        : _("key has been created %lu seconds "
1872                            "in future (time warp or clock problem)\n"), d );
1873         if( !opt.ignore_time_conflict ) {
1874             rc = GPGERR_TIME_CONFLICT;
1875             goto leave;
1876         }
1877     }
1878
1879
1880     /* unprotect to get the passphrase */
1881     switch( is_secret_key_protected( sk ) ) {
1882       case -1:
1883         rc = GPGERR_PUBKEY_ALGO;
1884         break;
1885       case 0:
1886         tty_printf("This key is not protected.\n");
1887         break;
1888       default:
1889         tty_printf("Key is protected.\n");
1890         rc = check_secret_key( sk, 0 );
1891         if( !rc )
1892             passphrase = get_last_passphrase();
1893         break;
1894     }
1895     if( rc )
1896         goto leave;
1897
1898
1899     algo = ask_algo( 1 );
1900     assert(algo);
1901     nbits = ask_keysize( algo );
1902     expire = ask_expire_interval();
1903     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
1904                                                   _("Really create? ") ) )
1905         goto leave;
1906
1907     if( passphrase ) {
1908         s2k = gcry_xmalloc_secure( sizeof *s2k );
1909         s2k->mode = opt.s2k_mode;
1910         s2k->hash_algo = opt.s2k_digest_algo;
1911         set_next_passphrase( passphrase );
1912         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2 );
1913     }
1914
1915     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
1916                                       dek, s2k, NULL, expire );
1917     if( !rc )
1918         rc = write_keybinding(pub_keyblock, pub_keyblock, sk);
1919     if( !rc )
1920         rc = write_keybinding(sec_keyblock, pub_keyblock, sk);
1921     if( !rc )
1922         okay = 1;
1923
1924   leave:
1925     if( rc )
1926         log_error(_("Key generation failed: %s\n"), gpg_errstr(rc) );
1927     gcry_free( passphrase );
1928     gcry_free( dek );
1929     gcry_free( s2k );
1930     if( sk ) /* release the copy of the (now unprotected) secret key */
1931         free_secret_key(sk);
1932     set_next_passphrase( NULL );
1933     return okay;
1934 }
1935
1936 /****************
1937  * Write a keyblock to an output stream
1938  */
1939 static int
1940 write_keyblock( IOBUF out, KBNODE node )
1941 {
1942     for( ; node ; node = node->next ) {
1943         int rc = build_packet( out, node->pkt );
1944         if( rc ) {
1945             log_error("build_packet(%d) failed: %s\n",
1946                         node->pkt->pkttype, gpg_errstr(rc) );
1947             return GPGERR_WRITE_FILE;
1948         }
1949     }
1950     return 0;
1951 }
1952