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