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