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