See ChangeLog: Mon Sep 18 16:35:45 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_CAST5;
140     buf[2] = GCRY_CIPHER_BLOWFISH;
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
893                 if( opt.allow_freeform_uid )
894                     break;
895
896                 if( strpbrk( aname, "<>" ) )
897                     tty_printf(_("Invalid character in name\n"));
898                 else if( isdigit(*aname) )
899                     tty_printf(_("Name may not start with a digit\n"));
900                 else if( strlen(aname) < 5 )
901                     tty_printf(_("Name must be at least 5 characters long\n"));
902                 else
903                     break;
904             }
905         }
906         if( !amail ) {
907             for(;;) {
908                 gcry_free(amail);
909                 amail = cpr_get("keygen.email",_("Email address: "));
910                 trim_spaces(amail);
911                 cpr_kill_prompt();
912                 if( !*amail )
913                     break;   /* no email address is okay */
914                 else if( has_invalid_email_chars(amail)
915                          || string_count_chr(amail,'@') != 1
916                          || *amail == '@'
917                          || amail[strlen(amail)-1] == '@'
918                          || amail[strlen(amail)-1] == '.'
919                          || strstr(amail, "..") )
920                     tty_printf(_("Not a valid email address\n"));
921                 else
922                     break;
923             }
924         }
925         if( !acomment ) {
926             for(;;) {
927                 gcry_free(acomment);
928                 acomment = cpr_get("keygen.comment",_("Comment: "));
929                 trim_spaces(acomment);
930                 cpr_kill_prompt();
931                 if( !*acomment )
932                     break;   /* no comment is okay */
933                 else if( strpbrk( acomment, "()" ) )
934                     tty_printf(_("Invalid character in comment\n"));
935                 else
936                     break;
937             }
938         }
939
940
941         gcry_free(uid);
942         uid = p = gcry_xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
943         p = stpcpy(p, aname );
944         if( *acomment )
945             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
946         if( *amail )
947             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
948
949         /* append a warning if we do not have dev/random
950          * or it is switched into  quick testmode */
951         #warning quick_random_gen() not available
952       #if 0
953         if( quick_random_gen(-1) )
954             strcpy(p, " (INSECURE!)" );
955       #endif
956
957         /* print a note in case that UTF8 mapping has to be done */
958         for(p=uid; *p; p++ ) {
959             if( *p & 0x80 ) {
960                 tty_printf(_("You are using the `%s' character set.\n"),
961                            get_native_charset() );
962                 break;
963             }
964         }
965
966         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
967         /* fixme: add a warning if this user-id already exists */
968         if( !*amail && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
969             fail = 1;
970             tty_printf(_("Please don't put the email address "
971                           "into the real name or the comment\n") );
972         }
973
974         for(;;) {
975             char *ansstr = _("NnCcEeOoQq");
976
977             if( strlen(ansstr) != 10 )
978                 BUG();
979             if( cpr_enabled() ) {
980                 answer = gcry_xstrdup(ansstr+6);
981                 answer[1] = 0;
982             }
983             else {
984                 answer = cpr_get("keygen.userid.cmd", fail?
985                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
986                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
987                 cpr_kill_prompt();
988             }
989             if( strlen(answer) > 1 )
990                 ;
991             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
992                 gcry_free(aname); aname = NULL;
993                 break;
994             }
995             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
996                 gcry_free(acomment); acomment = NULL;
997                 break;
998             }
999             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1000                 gcry_free(amail); amail = NULL;
1001                 break;
1002             }
1003             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1004                 if( fail ) {
1005                     tty_printf(_("Please correct the error first\n"));
1006                 }
1007                 else {
1008                     gcry_free(aname); aname = NULL;
1009                     gcry_free(acomment); acomment = NULL;
1010                     gcry_free(amail); amail = NULL;
1011                     break;
1012                 }
1013             }
1014             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1015                 gcry_free(aname); aname = NULL;
1016                 gcry_free(acomment); acomment = NULL;
1017                 gcry_free(amail); amail = NULL;
1018                 gcry_free(uid); uid = NULL;
1019                 break;
1020             }
1021             gcry_free(answer);
1022         }
1023         gcry_free(answer);
1024         if( !amail && !acomment && !amail )
1025             break;
1026         gcry_free(uid); uid = NULL;
1027     }
1028     if( uid ) {
1029         char *p = native_to_utf8( uid );
1030         gcry_free( uid );
1031         uid = p;
1032     }
1033     return uid;
1034 }
1035
1036
1037 static DEK *
1038 ask_passphrase( STRING2KEY **ret_s2k )
1039 {
1040     DEK *dek = NULL;
1041     STRING2KEY *s2k;
1042
1043     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1044
1045     s2k = gcry_xmalloc_secure( sizeof *s2k );
1046     for(;;) {
1047         s2k->mode = opt.s2k_mode;
1048         s2k->hash_algo = opt.s2k_digest_algo;
1049         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2 );
1050         if( !dek ) {
1051             tty_printf(_("passphrase not correctly repeated; try again.\n"));
1052         }
1053         else if( !dek->keylen ) {
1054             gcry_free(dek); dek = NULL;
1055             gcry_free(s2k); s2k = NULL;
1056             tty_printf(_(
1057             "You don't want a passphrase - this is probably a *bad* idea!\n"
1058             "I will do it anyway.  You can change your passphrase at any time,\n"
1059             "using this program with the option \"--edit-key\".\n\n"));
1060             break;
1061         }
1062         else
1063             break; /* okay */
1064     }
1065     *ret_s2k = s2k;
1066     return dek;
1067 }
1068
1069
1070 static int
1071 do_create( int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root,
1072            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate )
1073 {
1074     int rc=0;
1075
1076     if( !opt.batch )
1077         tty_printf(_(
1078 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1079 "some other action (type on the keyboard, move the mouse, utilize the\n"
1080 "disks) during the prime generation; this gives the random number\n"
1081 "generator a better chance to gain enough entropy.\n") );
1082
1083     if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E )
1084         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1085     else if( algo == GCRY_PK_DSA )
1086         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1087   #if 0
1088     else if( algo == GCRY_PK_RSA )
1089         rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1090   #endif
1091     else
1092         BUG();
1093
1094   #ifdef ENABLE_COMMENT_PACKETS
1095     if( !rc ) {
1096         add_kbnode( pub_root,
1097                 make_comment_node("#created by GNUPG v" VERSION " ("
1098                                             PRINTABLE_OS_NAME ")"));
1099         add_kbnode( sec_root,
1100                 make_comment_node("#created by GNUPG v" VERSION " ("
1101                                             PRINTABLE_OS_NAME ")"));
1102     }
1103   #endif
1104     return rc;
1105 }
1106
1107
1108 /****************
1109  * Generate a new user id packet, or return NULL if canceled
1110  */
1111 PKT_user_id *
1112 generate_user_id()
1113 {
1114     PKT_user_id *uid;
1115     char *p;
1116     size_t n;
1117
1118     p = ask_user_id( 1 );
1119     if( !p )
1120         return NULL;
1121     n = strlen(p);
1122     uid = gcry_xcalloc( 1, sizeof *uid + n - 1 );
1123     uid->len = n;
1124     strcpy(uid->name, p);
1125     return uid;
1126 }
1127
1128
1129 static void
1130 release_parameter_list( struct para_data_s *r )
1131 {
1132     struct para_data_s *r2;
1133
1134     for( ; r ; r = r2 ) {
1135         r2 = r->next;
1136         if( r->key == pPASSPHRASE_DEK )
1137             gcry_free( r->u.dek );
1138         else if( r->key == pPASSPHRASE_S2K )
1139             gcry_free( r->u.s2k );
1140
1141         gcry_free(r);
1142     }
1143 }
1144
1145 static struct para_data_s *
1146 get_parameter( struct para_data_s *para, enum para_name key )
1147 {
1148     struct para_data_s *r;
1149
1150     for( r = para; r && r->key != key; r = r->next )
1151         ;
1152     return r;
1153 }
1154
1155 static const char *
1156 get_parameter_value( struct para_data_s *para, enum para_name key )
1157 {
1158     struct para_data_s *r = get_parameter( para, key );
1159     return (r && *r->u.value)? r->u.value : NULL;
1160 }
1161
1162 static int
1163 get_parameter_algo( struct para_data_s *para, enum para_name key )
1164 {
1165     struct para_data_s *r = get_parameter( para, key );
1166     if( !r )
1167         return -1;
1168     if( isdigit( *r->u.value ) )
1169         return atoi( r->u.value );
1170     return gcry_pk_map_name( r->u.value );
1171 }
1172
1173
1174 static u32
1175 get_parameter_u32( struct para_data_s *para, enum para_name key )
1176 {
1177     struct para_data_s *r = get_parameter( para, key );
1178
1179     if( !r )
1180         return 0;
1181     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1182         return r->u.expire;
1183
1184     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1185 }
1186
1187 static unsigned int
1188 get_parameter_uint( struct para_data_s *para, enum para_name key )
1189 {
1190     return get_parameter_u32( para, key );
1191 }
1192
1193 static DEK *
1194 get_parameter_dek( struct para_data_s *para, enum para_name key )
1195 {
1196     struct para_data_s *r = get_parameter( para, key );
1197     return r? r->u.dek : NULL;
1198 }
1199
1200 static STRING2KEY *
1201 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1202 {
1203     struct para_data_s *r = get_parameter( para, key );
1204     return r? r->u.s2k : NULL;
1205 }
1206
1207
1208 static int
1209 proc_parameter_file( struct para_data_s *para, const char *fname,
1210                                        struct output_control_s *outctrl )
1211 {
1212     struct para_data_s *r;
1213     const char *s1, *s2, *s3;
1214     size_t n;
1215     char *p;
1216     int i;
1217
1218     /* check that we have all required parameters */
1219     assert( get_parameter( para, pKEYTYPE ) );
1220     i = get_parameter_algo( para, pKEYTYPE );
1221     if( i < 1 || openpgp_pk_test_algo( i, GCRY_PK_USAGE_SIGN ) ) {
1222         r = get_parameter( para, pKEYTYPE );
1223         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1224         return -1;
1225     }
1226
1227     i = get_parameter_algo( para, pSUBKEYTYPE );
1228     if( i > 1 && openpgp_pk_test_algo( i, 0 ) ) {
1229         r = get_parameter( para, pSUBKEYTYPE );
1230         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1231         return -1;
1232     }
1233
1234     if( !get_parameter_value( para, pUSERID ) ) {
1235         /* create the formatted user ID */
1236         s1 = get_parameter_value( para, pNAMEREAL );
1237         s2 = get_parameter_value( para, pNAMECOMMENT );
1238         s3 = get_parameter_value( para, pNAMEEMAIL );
1239         if( s1 || s2 || s3 ) {
1240             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1241             r = gcry_xcalloc( 1, sizeof *r + n + 20 );
1242             r->key = pUSERID;
1243             p = r->u.value;
1244             if( s1 )
1245                 p = stpcpy(p, s1 );
1246             if( s2 )
1247                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1248             if( s3 )
1249                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1250             r->next = para;
1251             para = r;
1252         }
1253     }
1254
1255     /* make DEK and S2K from the Passphrase */
1256     r = get_parameter( para, pPASSPHRASE );
1257     if( r && *r->u.value ) {
1258         /* we have a plain text passphrase - create a DEK from it.
1259          * It is a little bit ridiculous to keep it ih secure memory
1260          * but becuase we do this alwasy, why not here */
1261         STRING2KEY *s2k;
1262         DEK *dek;
1263
1264         s2k = gcry_xmalloc_secure( sizeof *s2k );
1265         s2k->mode = opt.s2k_mode;
1266         s2k->hash_algo = opt.s2k_digest_algo;
1267         set_next_passphrase( r->u.value );
1268         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2 );
1269         set_next_passphrase( NULL );
1270         assert( dek );
1271         memset( r->u.value, 0, strlen(r->u.value) );
1272
1273         r = gcry_xcalloc( 1, sizeof *r );
1274         r->key = pPASSPHRASE_S2K;
1275         r->u.s2k = s2k;
1276         r->next = para;
1277         para = r;
1278         r = gcry_xcalloc( 1, sizeof *r );
1279         r->key = pPASSPHRASE_DEK;
1280         r->u.dek = dek;
1281         r->next = para;
1282         para = r;
1283     }
1284
1285     /* make KEYEXPIRE from Expire-Date */
1286     r = get_parameter( para, pEXPIREDATE );
1287     if( r && *r->u.value ) {
1288         i = parse_expire_string( r->u.value );
1289         if( i < 0 ) {
1290             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1291             return -1;
1292         }
1293         r->u.expire = i * 86400L;
1294         r->key = pKEYEXPIRE;  /* change hat entry */
1295         /* also set it for the subkey */
1296         r = gcry_xcalloc( 1, sizeof *r + 20 );
1297         r->key = pSUBKEYEXPIRE;
1298         r->u.expire = i * 86400L;
1299         r->next = para;
1300         para = r;
1301     }
1302
1303     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
1304         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
1305         return -1;
1306     }
1307
1308     do_generate_keypair( para, outctrl );
1309     return 0;
1310 }
1311
1312
1313 /****************
1314  * Kludge to allow non interactive key generation controlled
1315  * by a parameter file (which currently is only stdin)
1316  * Note, that string parameters are expected to be in UTF-8
1317  */
1318 static void
1319 read_parameter_file( const char *fname )
1320 {
1321     static struct { const char *name;
1322                     enum para_name key;
1323     } keywords[] = {
1324         { "Key-Type",       pKEYTYPE},
1325         { "Key-Length",     pKEYLENGTH },
1326         { "Subkey-Type",    pSUBKEYTYPE },
1327         { "Subkey-Length",  pSUBKEYLENGTH },
1328         { "Name-Real",      pNAMEREAL },
1329         { "Name-Email",     pNAMEEMAIL },
1330         { "Name-Comment",   pNAMECOMMENT },
1331         { "Expire-Date",    pEXPIREDATE },
1332         { "Passphrase",     pPASSPHRASE },
1333         { NULL, 0 }
1334     };
1335     FILE *fp;
1336     char line[1024], *p;
1337     int lnr;
1338     const char *err = NULL;
1339     struct para_data_s *para, *r;
1340     int i;
1341     struct output_control_s outctrl;
1342
1343     memset( &outctrl, 0, sizeof( outctrl ) );
1344
1345     if( !fname || !*fname || !strcmp(fname,"-") ) {
1346         fp = stdin;
1347         fname = "-";
1348     }
1349     else {
1350         fp = fopen( fname, "r" );
1351         if( !fp ) {
1352             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
1353             return;
1354         }
1355     }
1356
1357     lnr = 0;
1358     err = NULL;
1359     para = NULL;
1360     while( fgets( line, DIM(line)-1, fp ) ) {
1361         char *keyword, *value;
1362
1363         lnr++;
1364         if( *line && line[strlen(line)-1] != '\n' ) {
1365             err = "line too long";
1366             break;
1367         }
1368         for( p = line; isspace(*p); p++ )
1369             ;
1370         if( !*p || *p == '#' )
1371             continue;
1372         keyword = p;
1373         if( *keyword == '%' ) {
1374             for( ; !isspace(*p); p++ )
1375                 ;
1376             if( *p )
1377                 *p++ = 0;
1378             for( ; isspace(*p); p++ )
1379                 ;
1380             value = p;
1381             trim_trailing_ws( value, strlen(value) );
1382             if( !stricmp( keyword, "%echo" ) )
1383                 log_info("%s\n", value );
1384             else if( !stricmp( keyword, "%dry-run" ) )
1385                 outctrl.dryrun = 1;
1386             else if( !stricmp( keyword, "%commit" ) ) {
1387                 outctrl.lnr = lnr;
1388                 proc_parameter_file( para, fname, &outctrl );
1389                 release_parameter_list( para );
1390                 para = NULL;
1391             }
1392             else if( !stricmp( keyword, "%pubring" ) ) {
1393                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
1394                     ; /* still the same file - ignore it */
1395                 else {
1396                     gcry_free( outctrl.pub.newfname );
1397                     outctrl.pub.newfname = gcry_xstrdup( value );
1398                     outctrl.use_files = 1;
1399                 }
1400             }
1401             else if( !stricmp( keyword, "%secring" ) ) {
1402                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
1403                     ; /* still the same file - ignore it */
1404                 else {
1405                    gcry_free( outctrl.sec.newfname );
1406                    outctrl.sec.newfname = gcry_xstrdup( value );
1407                    outctrl.use_files = 1;
1408                 }
1409             }
1410             else
1411                 log_info("skipping control `%s' (%s)\n", keyword, value );
1412
1413
1414             continue;
1415         }
1416
1417
1418         if( !(p = strchr( p, ':' )) || p == keyword ) {
1419             err = "missing colon";
1420             break;
1421         }
1422         if( *p )
1423             *p++ = 0;
1424         for( ; isspace(*p); p++ )
1425             ;
1426         if( !*p ) {
1427             err = "missing argument";
1428             break;
1429         }
1430         value = p;
1431         trim_trailing_ws( value, strlen(value) );
1432
1433         for(i=0; keywords[i].name; i++ ) {
1434             if( !stricmp( keywords[i].name, keyword ) )
1435                 break;
1436         }
1437         if( !keywords[i].name ) {
1438             err = "unknown keyword";
1439             break;
1440         }
1441         if( keywords[i].key != pKEYTYPE && !para ) {
1442             err = "parameter block does not start with \"Key-Type\"";
1443             break;
1444         }
1445
1446         if( keywords[i].key == pKEYTYPE && para ) {
1447             outctrl.lnr = lnr;
1448             proc_parameter_file( para, fname, &outctrl );
1449             release_parameter_list( para );
1450             para = NULL;
1451         }
1452         else {
1453             for( r = para; r; r = r->next ) {
1454                 if( r->key == keywords[i].key )
1455                     break;
1456             }
1457             if( r ) {
1458                 err = "duplicate keyword";
1459                 break;
1460             }
1461         }
1462         r = gcry_xcalloc( 1, sizeof *r + strlen( value ) );
1463         r->lnr = lnr;
1464         r->key = keywords[i].key;
1465         strcpy( r->u.value, value );
1466         r->next = para;
1467         para = r;
1468     }
1469     if( err )
1470         log_error("%s:%d: %s\n", fname, lnr, err );
1471     else if( ferror(fp) ) {
1472         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
1473     }
1474     else if( para ) {
1475         outctrl.lnr = lnr;
1476         proc_parameter_file( para, fname, &outctrl );
1477     }
1478
1479     if( outctrl.use_files ) { /* close open streams */
1480         iobuf_close( outctrl.pub.stream );
1481         iobuf_close( outctrl.sec.stream );
1482         gcry_free( outctrl.pub.fname );
1483         gcry_free( outctrl.pub.newfname );
1484         gcry_free( outctrl.sec.fname );
1485         gcry_free( outctrl.sec.newfname );
1486     }
1487
1488     release_parameter_list( para );
1489     if( strcmp( fname, "-" ) )
1490         fclose(fp);
1491 }
1492
1493
1494 /****************
1495  * Generate a keypair
1496  * (fname is only used in batch mode)
1497  */
1498 void
1499 generate_keypair( const char *fname )
1500 {
1501     unsigned int nbits;
1502     char *uid = NULL;
1503     DEK *dek;
1504     STRING2KEY *s2k;
1505     int algo;
1506     int both = 0;
1507     u32 expire;
1508     struct para_data_s *para = NULL;
1509     struct para_data_s *r;
1510     struct output_control_s outctrl;
1511
1512     memset( &outctrl, 0, sizeof( outctrl ) );
1513
1514     if( opt.batch ) {
1515         read_parameter_file( fname );
1516         return;
1517     }
1518
1519     algo = ask_algo( 0 );
1520     if( !algo ) { /* default: DSA with ElG subkey of the specified size */
1521         both = 1;
1522         r = gcry_xcalloc( 1, sizeof *r + 20 );
1523         r->key = pKEYTYPE;
1524         sprintf( r->u.value, "%d", GCRY_PK_DSA );
1525         r->next = para;
1526         para = r;
1527         tty_printf(_("DSA keypair will have 1024 bits.\n"));
1528         r = gcry_xcalloc( 1, sizeof *r + 20 );
1529         r->key = pKEYLENGTH;
1530         strcpy( r->u.value, "1024" );
1531         r->next = para;
1532         para = r;
1533
1534         algo = GCRY_PK_ELG_E;
1535         r = gcry_xcalloc( 1, sizeof *r + 20 );
1536         r->key = pSUBKEYTYPE;
1537         sprintf( r->u.value, "%d", algo );
1538         r->next = para;
1539         para = r;
1540     }
1541     else {
1542         r = gcry_xcalloc( 1, sizeof *r + 20 );
1543         r->key = pKEYTYPE;
1544         sprintf( r->u.value, "%d", algo );
1545         r->next = para;
1546         para = r;
1547     }
1548
1549     nbits = ask_keysize( algo );
1550     r = gcry_xcalloc( 1, sizeof *r + 20 );
1551     r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
1552     sprintf( r->u.value, "%u", nbits);
1553     r->next = para;
1554     para = r;
1555
1556     expire = ask_expire_interval();
1557     r = gcry_xcalloc( 1, sizeof *r + 20 );
1558     r->key = pKEYEXPIRE;
1559     r->u.expire = expire;
1560     r->next = para;
1561     para = r;
1562     r = gcry_xcalloc( 1, sizeof *r + 20 );
1563     r->key = pSUBKEYEXPIRE;
1564     r->u.expire = expire;
1565     r->next = para;
1566     para = r;
1567
1568     uid = ask_user_id(0);
1569     if( !uid ) {
1570         log_error(_("Key generation canceled.\n"));
1571         release_parameter_list( para );
1572         return;
1573     }
1574     r = gcry_xcalloc( 1, sizeof *r + strlen(uid) );
1575     r->key = pUSERID;
1576     strcpy( r->u.value, uid );
1577     r->next = para;
1578     para = r;
1579
1580     dek = ask_passphrase( &s2k );
1581     if( dek ) {
1582         r = gcry_xcalloc( 1, sizeof *r );
1583         r->key = pPASSPHRASE_DEK;
1584         r->u.dek = dek;
1585         r->next = para;
1586         para = r;
1587         r = gcry_xcalloc( 1, sizeof *r );
1588         r->key = pPASSPHRASE_S2K;
1589         r->u.s2k = s2k;
1590         r->next = para;
1591         para = r;
1592     }
1593
1594     proc_parameter_file( para, "[internal]", &outctrl );
1595     release_parameter_list( para );
1596 }
1597
1598
1599 static void
1600 do_generate_keypair( struct para_data_s *para,
1601                      struct output_control_s *outctrl )
1602 {
1603     char *pub_fname = NULL;
1604     char *sec_fname = NULL;
1605     KBNODE pub_root = NULL;
1606     KBNODE sec_root = NULL;
1607     PKT_secret_key *sk = NULL;
1608     const char *s;
1609     int rc;
1610
1611     if( outctrl->dryrun ) {
1612         log_info("dry-run mode - key generation skipped\n");
1613         return;
1614     }
1615
1616
1617     if( outctrl->use_files ) {
1618         if( outctrl->pub.newfname ) {
1619             iobuf_close(outctrl->pub.stream);
1620             outctrl->pub.stream = NULL;
1621             gcry_free( outctrl->pub.fname );
1622             outctrl->pub.fname =  outctrl->pub.newfname;
1623             outctrl->pub.newfname = NULL;
1624
1625             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
1626             if( !outctrl->pub.stream ) {
1627                 log_error("can't create `%s': %s\n", outctrl->pub.newfname,
1628                                                      strerror(errno) );
1629                 return;
1630             }
1631             if( opt.armor ) {
1632                 outctrl->pub.afx.what = 1;
1633                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
1634                                                     &outctrl->pub.afx );
1635             }
1636         }
1637         if( outctrl->sec.newfname ) {
1638             iobuf_close(outctrl->sec.stream);
1639             outctrl->sec.stream = NULL;
1640             gcry_free( outctrl->sec.fname );
1641             outctrl->sec.fname =  outctrl->sec.newfname;
1642             outctrl->sec.newfname = NULL;
1643
1644             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
1645             if( !outctrl->sec.stream ) {
1646                 log_error("can't create `%s': %s\n", outctrl->sec.newfname,
1647                                                      strerror(errno) );
1648                 return;
1649             }
1650             if( opt.armor ) {
1651                 outctrl->sec.afx.what = 5;
1652                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
1653                                                     &outctrl->sec.afx );
1654             }
1655         }
1656         pub_fname = outctrl->pub.fname; /* only for info output */
1657         sec_fname = outctrl->sec.fname; /* only for info output */
1658         assert( outctrl->pub.stream );
1659         assert( outctrl->sec.stream );
1660     }
1661     else {
1662         pub_fname = get_writable_keyblock_file( 0 );
1663         sec_fname = get_writable_keyblock_file( 1 );
1664     }
1665
1666     if( opt.verbose ) {
1667         log_info(_("writing public key to `%s'\n"), pub_fname );
1668         log_info(_("writing secret key to `%s'\n"), sec_fname );
1669     }
1670
1671     /* we create the packets as a tree of kbnodes. Because the structure
1672      * we create is known in advance we simply generate a linked list
1673      * The first packet is a dummy comment packet which we flag
1674      * as deleted.  The very first packet must always be a KEY packet.
1675      */
1676     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
1677     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
1678
1679     rc = do_create( get_parameter_algo( para, pKEYTYPE ),
1680                     get_parameter_uint( para, pKEYLENGTH ),
1681                     pub_root, sec_root,
1682                     get_parameter_dek( para, pPASSPHRASE_DEK ),
1683                     get_parameter_s2k( para, pPASSPHRASE_S2K ),
1684                     &sk,
1685                     get_parameter_u32( para, pKEYEXPIRE ) );
1686     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
1687         write_uid(pub_root, s );
1688         if( !rc )
1689             write_uid(sec_root, s );
1690         if( !rc )
1691             rc = write_selfsig(pub_root, pub_root, sk);
1692         if( !rc )
1693             rc = write_selfsig(sec_root, pub_root, sk);
1694     }
1695
1696     if( get_parameter( para, pSUBKEYTYPE ) ) {
1697         rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
1698                         get_parameter_uint( para, pSUBKEYLENGTH ),
1699                         pub_root, sec_root,
1700                         get_parameter_dek( para, pPASSPHRASE_DEK ),
1701                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
1702                         NULL,
1703                         get_parameter_u32( para, pSUBKEYEXPIRE ) );
1704         if( !rc )
1705             rc = write_keybinding(pub_root, pub_root, sk);
1706         if( !rc )
1707             rc = write_keybinding(sec_root, pub_root, sk);
1708     }
1709
1710
1711     if( !rc && outctrl->use_files ) { /* direct write to specified files */
1712         rc = write_keyblock( outctrl->pub.stream, pub_root );
1713         if( rc )
1714             log_error("can't write public key: %s\n", gpg_errstr(rc) );
1715         if( !rc ) {
1716             rc = write_keyblock( outctrl->sec.stream, sec_root );
1717             if( rc )
1718                 log_error("can't write secret key: %s\n", gpg_errstr(rc) );
1719         }
1720
1721     }
1722     else if( !rc ) { /* write to the standard keyrings */
1723         KBPOS pub_kbpos;
1724         KBPOS sec_kbpos;
1725         int rc1 = -1;
1726         int rc2 = -1;
1727
1728         /* we can now write the certificates */
1729         if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
1730             if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
1731                 log_error("can add keyblock file `%s'\n", pub_fname );
1732                 rc = GPGERR_CREATE_FILE;
1733             }
1734             else if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
1735                 log_error("can get keyblock handle for `%s'\n", pub_fname );
1736                 rc = GPGERR_CREATE_FILE;
1737             }
1738         }
1739         if( rc )
1740             ;
1741         else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
1742             if( add_keyblock_resource( sec_fname, 1, 1 ) ) {
1743                 log_error("can add keyblock file `%s'\n", sec_fname );
1744                 rc = GPGERR_CREATE_FILE;
1745             }
1746             else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
1747                 log_error("can get keyblock handle for `%s'\n", sec_fname );
1748                 rc = GPGERR_CREATE_FILE;
1749             }
1750         }
1751
1752         if( rc )
1753             ;
1754         else if( (rc=rc1=lock_keyblock( &pub_kbpos )) )
1755             log_error("can't lock public keyring: %s\n", gpg_errstr(rc) );
1756         else if( (rc=rc2=lock_keyblock( &sec_kbpos )) )
1757             log_error("can't lock secret keyring: %s\n", gpg_errstr(rc) );
1758         else if( (rc=insert_keyblock( &pub_kbpos, pub_root )) )
1759             log_error("can't write public key: %s\n", gpg_errstr(rc) );
1760         else if( (rc=insert_keyblock( &sec_kbpos, sec_root )) )
1761             log_error("can't write secret key: %s\n", gpg_errstr(rc) );
1762         else {
1763             if( !opt.batch )
1764                  tty_printf(_("public and secret key created and signed.\n") );
1765             if( !opt.batch
1766                 && get_parameter_algo( para, pKEYTYPE ) == GCRY_PK_DSA
1767                 && !get_parameter( para, pSUBKEYTYPE ) )
1768             {
1769                 tty_printf(_("Note that this key cannot be used for "
1770                              "encryption.  You may want to use\n"
1771                              "the command \"--edit-key\" to generate a "
1772                              "secondary key for this purpose.\n") );
1773             }
1774         }
1775
1776         if( !rc1 )
1777             unlock_keyblock( &pub_kbpos );
1778         if( !rc2 )
1779             unlock_keyblock( &sec_kbpos );
1780     }
1781
1782     if( rc ) {
1783         if( opt.batch )
1784             log_error("key generation failed: %s\n", gpg_errstr(rc) );
1785         else
1786             tty_printf(_("Key generation failed: %s\n"), gpg_errstr(rc) );
1787     }
1788     release_kbnode( pub_root );
1789     release_kbnode( sec_root );
1790     if( sk ) /* the unprotected  secret key */
1791         free_secret_key(sk);
1792     if( !outctrl->use_files ) {
1793         gcry_free(pub_fname);
1794         gcry_free(sec_fname);
1795     }
1796 }
1797
1798
1799 /****************
1800  * add a new subkey to an existing key.
1801  * Returns true if a new key has been generated and put into the keyblocks.
1802  */
1803 int
1804 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
1805 {
1806     int okay=0, rc=0;
1807     KBNODE node;
1808     PKT_secret_key *sk = NULL; /* this is the primary sk */
1809     int algo;
1810     u32 expire;
1811     unsigned nbits;
1812     char *passphrase = NULL;
1813     DEK *dek = NULL;
1814     STRING2KEY *s2k = NULL;
1815     u32 cur_time;
1816
1817     /* break out the primary secret key */
1818     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
1819     if( !node ) {
1820         log_error("Oops; secret key not found anymore!\n");
1821         goto leave;
1822     }
1823
1824     /* make a copy of the sk to keep the protected one in the keyblock */
1825     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
1826
1827     cur_time = make_timestamp();
1828     if( sk->timestamp > cur_time ) {
1829         ulong d = sk->timestamp - cur_time;
1830         log_info( d==1 ? _("key has been created %lu second "
1831                            "in future (time warp or clock problem)\n")
1832                        : _("key has been created %lu seconds "
1833                            "in future (time warp or clock problem)\n"), d );
1834         if( !opt.ignore_time_conflict ) {
1835             rc = GPGERR_TIME_CONFLICT;
1836             goto leave;
1837         }
1838     }
1839
1840
1841     /* unprotect to get the passphrase */
1842     switch( is_secret_key_protected( sk ) ) {
1843       case -1:
1844         rc = GPGERR_PUBKEY_ALGO;
1845         break;
1846       case 0:
1847         tty_printf("This key is not protected.\n");
1848         break;
1849       default:
1850         tty_printf("Key is protected.\n");
1851         rc = check_secret_key( sk, 0 );
1852         if( !rc )
1853             passphrase = get_last_passphrase();
1854         break;
1855     }
1856     if( rc )
1857         goto leave;
1858
1859
1860     algo = ask_algo( 1 );
1861     assert(algo);
1862     nbits = ask_keysize( algo );
1863     expire = ask_expire_interval();
1864     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
1865                                                   _("Really create? ") ) )
1866         goto leave;
1867
1868     if( passphrase ) {
1869         s2k = gcry_xmalloc_secure( sizeof *s2k );
1870         s2k->mode = opt.s2k_mode;
1871         s2k->hash_algo = opt.s2k_digest_algo;
1872         set_next_passphrase( passphrase );
1873         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2 );
1874     }
1875
1876     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
1877                                       dek, s2k, NULL, expire );
1878     if( !rc )
1879         rc = write_keybinding(pub_keyblock, pub_keyblock, sk);
1880     if( !rc )
1881         rc = write_keybinding(sec_keyblock, pub_keyblock, sk);
1882     if( !rc )
1883         okay = 1;
1884
1885   leave:
1886     if( rc )
1887         log_error(_("Key generation failed: %s\n"), gpg_errstr(rc) );
1888     gcry_free( passphrase );
1889     gcry_free( dek );
1890     gcry_free( s2k );
1891     if( sk ) /* release the copy of the (now unprotected) secret key */
1892         free_secret_key(sk);
1893     set_next_passphrase( NULL );
1894     return okay;
1895 }
1896
1897 /****************
1898  * Write a keyblock to an output stream
1899  */
1900 static int
1901 write_keyblock( IOBUF out, KBNODE node )
1902 {
1903     for( ; node ; node = node->next ) {
1904         int rc = build_packet( out, node->pkt );
1905         if( rc ) {
1906             log_error("build_packet(%d) failed: %s\n",
1907                         node->pkt->pkttype, gpg_errstr(rc) );
1908             return GPGERR_WRITE_FILE;
1909         }
1910     }
1911     return 0;
1912 }
1913