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