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