bug fixes
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - generate a key pair
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * This file is part of G10.
5  *
6  * G10 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  * G10 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 "main.h"
30 #include "packet.h"
31 #include "cipher.h"
32 #include "ttyio.h"
33 #include "options.h"
34 #include "keydb.h"
35 #include "i18n.h"
36
37 #if 0
38   #define TEST_ALGO  1
39   #define TEST_NBITS 256
40   #define TEST_UID   "Karl Test"
41 #endif
42
43 #if defined(HAVE_RSA_CIPHER) && 0
44   #define ENABLE_RSA_KEYGEN 1
45 #endif
46
47
48 static u16
49 checksum_u16( unsigned n )
50 {
51     u16 a;
52
53     a  = (n >> 8) & 0xff;
54     a |= n & 0xff;
55     return a;
56 }
57
58 static u16
59 checksum( byte *p, unsigned n )
60 {
61     u16 a;
62
63     for(a=0; n; n-- )
64         a += *p++;
65     return a;
66 }
67
68 static u16
69 checksum_mpi( MPI a )
70 {
71     u16 csum;
72     byte *buffer;
73     unsigned nbytes;
74
75     buffer = mpi_get_buffer( a, &nbytes, NULL );
76     csum = checksum_u16( nbytes*8 );
77     csum += checksum( buffer, nbytes );
78     m_free( buffer );
79     return csum;
80 }
81
82
83
84 static void
85 write_uid( KBNODE root, const char *s )
86 {
87     PACKET *pkt = m_alloc_clear(sizeof *pkt );
88     size_t n = strlen(s);
89
90     pkt->pkttype = PKT_USER_ID;
91     pkt->pkt.user_id = m_alloc( sizeof *pkt->pkt.user_id + n - 1 );
92     pkt->pkt.user_id->len = n;
93     strcpy(pkt->pkt.user_id->name, s);
94     add_kbnode( root, new_kbnode( pkt ) );
95 }
96
97
98 static int
99 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_cert *skc )
100 {
101     PACKET *pkt;
102     PKT_signature *sig;
103     PKT_user_id *uid;
104     int rc=0;
105     KBNODE node;
106     PKT_public_cert *pkc;
107
108     if( opt.verbose )
109         log_info(_("writing self signature\n"));
110
111     /* get the uid packet from the list */
112     node = find_kbnode( root, PKT_USER_ID );
113     if( !node )
114         BUG(); /* no user id packet in tree */
115     uid = node->pkt->pkt.user_id;
116     /* get the pkc packet from the pub_tree */
117     node = find_kbnode( pub_root, PKT_PUBLIC_CERT );
118     if( !node )
119         BUG();
120     pkc = node->pkt->pkt.public_cert;
121
122     /* and make the signature */
123     rc = make_keysig_packet( &sig, pkc, uid, skc, 0x13, DIGEST_ALGO_RMD160 );
124     if( rc ) {
125         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
126         return rc;
127     }
128
129     pkt = m_alloc_clear( sizeof *pkt );
130     pkt->pkttype = PKT_SIGNATURE;
131     pkt->pkt.signature = sig;
132     add_kbnode( root, new_kbnode( pkt ) );
133     return rc;
134 }
135
136
137 static int
138 gen_elg(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
139         PKT_secret_cert **ret_skc )
140 {
141     int rc;
142     int i;
143     PACKET *pkt;
144     PKT_secret_cert *skc;
145     PKT_public_cert *pkc;
146     ELG_public_key pk;
147     ELG_secret_key sk;
148     MPI *factors;
149
150     elg_generate( &pk, &sk, nbits, &factors );
151
152     skc = m_alloc_clear( sizeof *skc );
153     pkc = m_alloc_clear( sizeof *pkc );
154     skc->timestamp = pkc->timestamp = make_timestamp();
155     skc->valid_days = pkc->valid_days = 0; /* fixme: make it configurable*/
156     skc->pubkey_algo = pkc->pubkey_algo = PUBKEY_ALGO_ELGAMAL;
157                        memset(&pkc->mfx, 0, sizeof pkc->mfx);
158                        pkc->d.elg.p = pk.p;
159                        pkc->d.elg.g = pk.g;
160                        pkc->d.elg.y = pk.y;
161     skc->d.elg.p = sk.p;
162     skc->d.elg.g = sk.g;
163     skc->d.elg.y = sk.y;
164     skc->d.elg.x = sk.x;
165     skc->d.elg.is_protected = 0;
166     skc->d.elg.protect_algo = 0;
167
168     skc->d.elg.csum = checksum_mpi( skc->d.elg.x );
169     /* return an unprotected version of the skc */
170     *ret_skc = copy_secret_cert( NULL, skc );
171
172     if( dek ) {
173         skc->d.elg.protect_algo = CIPHER_ALGO_BLOWFISH;
174         randomize_buffer(skc->d.elg.protect.blowfish.iv, 8, 1);
175         rc = protect_secret_key( skc, dek );
176         if( rc ) {
177             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
178             free_public_cert(pkc);
179             free_secret_cert(skc);
180             return rc;
181         }
182     }
183
184     pkt = m_alloc_clear(sizeof *pkt);
185     pkt->pkttype = PKT_PUBLIC_CERT;
186     pkt->pkt.public_cert = pkc;
187     add_kbnode(pub_root, new_kbnode( pkt ));
188
189     /* don't know wether it make sense to have the factors, so for now
190      * we store them in the secret keyring (but they are of secret) */
191     pkt = m_alloc_clear(sizeof *pkt);
192     pkt->pkttype = PKT_SECRET_CERT;
193     pkt->pkt.secret_cert = skc;
194     add_kbnode(sec_root, new_kbnode( pkt ));
195     for(i=0; factors[i]; i++ )
196         add_kbnode( sec_root,
197                     make_mpi_comment_node("#:ELG_factor:", factors[i] ));
198
199     return 0;
200 }
201
202
203
204 #ifdef ENABLE_RSA_KEYGEN
205 static int
206 gen_rsa(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
207         PKT_secret_cert **ret_skc )
208 {
209     int rc;
210     PACKET *pkt;
211     PKT_secret_cert *skc;
212     PKT_public_cert *pkc;
213     RSA_public_key pk;
214     RSA_secret_key sk;
215
216     rsa_generate( &pk, &sk, nbits );
217
218     skc = m_alloc_clear( sizeof *skc );
219     pkc = m_alloc_clear( sizeof *pkc );
220     skc->timestamp = pkc->timestamp = make_timestamp();
221     skc->valid_days = pkc->valid_days = 0; /* fixme: make it configurable*/
222     skc->pubkey_algo = pkc->pubkey_algo = PUBKEY_ALGO_RSA;
223                        memset(&pkc->mfx, 0, sizeof pkc->mfx);
224                        pkc->d.rsa.rsa_n = pk.n;
225                        pkc->d.rsa.rsa_e = pk.e;
226     skc->d.rsa.rsa_n = sk.n;
227     skc->d.rsa.rsa_e = sk.e;
228     skc->d.rsa.rsa_d = sk.d;
229     skc->d.rsa.rsa_p = sk.p;
230     skc->d.rsa.rsa_q = sk.q;
231     skc->d.rsa.rsa_u = sk.u;
232     skc->d.rsa.csum  = checksum_mpi( skc->d.rsa.rsa_d );
233     skc->d.rsa.csum += checksum_mpi( skc->d.rsa.rsa_p );
234     skc->d.rsa.csum += checksum_mpi( skc->d.rsa.rsa_q );
235     skc->d.rsa.csum += checksum_mpi( skc->d.rsa.rsa_u );
236
237     /* return an unprotected version of the skc */
238     *ret_skc = copy_secret_cert( NULL, skc );
239
240     if( dek ) {
241         skc->d.rsa.is_protected = 1;
242         skc->d.rsa.protect_algo = CIPHER_ALGO_BLOWFISH;
243         randomize_buffer( skc->d.rsa.protect.blowfish.iv, 8, 1);
244         skc->d.rsa.csum += checksum( skc->d.rsa.protect.blowfish.iv, 8 );
245         rc = protect_secret_key( skc, dek );
246         if( rc ) {
247             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
248             free_public_cert(pkc);
249             free_secret_cert(skc);
250             return rc;
251         }
252     }
253
254     pkt = m_alloc_clear(sizeof *pkt);
255     pkt->pkttype = PKT_PUBLIC_CERT;
256     pkt->pkt.public_cert = pkc;
257     add_kbnode(pub_root, new_kbnode( pkt ));
258
259     pkt = m_alloc_clear(sizeof *pkt);
260     pkt->pkttype = PKT_SECRET_CERT;
261     pkt->pkt.secret_cert = skc;
262     add_kbnode(sec_root, new_kbnode( pkt ));
263
264     return rc;
265 }
266 #endif /*ENABLE_RSA_KEYGEN*/
267
268
269 static int
270 gen_dsa(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
271         PKT_secret_cert **ret_skc )
272 {
273     return G10ERR_GENERAL;
274 }
275
276
277
278 /****************
279  * Generate a keypair
280  */
281 void
282 generate_keypair()
283 {
284     char *answer;
285     unsigned nbits;
286     char *pub_fname = NULL;
287     char *sec_fname = NULL;
288     char *uid = NULL;
289     KBNODE pub_root = NULL;
290     KBNODE sec_root = NULL;
291     PKT_secret_cert *skc = NULL;
292     DEK *dek = NULL;
293     int rc;
294     int algo;
295     const char *algo_name;
296     char *aname, *acomment, *amail;
297
298 #ifndef TEST_ALGO
299     if( opt.batch || opt.answer_yes || opt.answer_no )
300         log_fatal(_("Key generation can only be used in interactive mode\n"));
301
302     tty_printf(_("Please select the algorithm to use:\n"
303                  "   (1) ElGamal is the suggested one.\n"
304                  "   (2) DSA can only be used for signatures.\n"));
305   #ifdef ENABLE_RSA_KEYGEN
306     tty_printf(_("   (3) RSA cannot be used in the U.S.\n"));
307   #endif
308 #endif
309
310     for(;;) {
311       #ifdef TEST_ALGO
312         algo = TEST_ALGO;
313       #else
314         #ifdef ENABLE_RSA_KEYGEN
315           answer = tty_get(_("Your selection? (1,2,3) "));
316        #else
317           answer = tty_get(_("Your selection? (1,2) "));
318        #endif
319         tty_kill_prompt();
320         algo = *answer? atoi(answer): 1;
321         m_free(answer);
322       #endif
323         if( algo == 1 ) {
324             algo = PUBKEY_ALGO_ELGAMAL;
325             algo_name = "ElGamal";
326             break;
327         }
328         else if( algo == 2 ) {
329             algo = PUBKEY_ALGO_DSA;
330             algo_name = "DSA";
331             tty_printf(_("Sorry; DSA is not yet supported.\n"));
332         }
333       #ifdef ENABLE_RSA_KEYGEN
334         else if( algo == 3 ) {
335             algo = PUBKEY_ALGO_RSA;
336             algo_name = "RSA";
337             break;
338         }
339       #endif
340     }
341
342
343
344     tty_printf(_("About to generate a new %s keypair.\n"
345                  "              minimum keysize is  768 bits\n"
346                  "              default keysize is 1024 bits\n"
347                  "    highest suggested keysize is 2048 bits\n"), algo_name );
348     for(;;) {
349       #ifdef TEST_NBITS
350         nbits = TEST_NBITS;
351       #else
352         answer = tty_get(_("What keysize do you want? (1024) "));
353         tty_kill_prompt();
354         nbits = *answer? atoi(answer): 1024;
355         m_free(answer);
356       #endif
357         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
358             tty_printf(_("DSA does only allow keysizes from 512 to 1024\n"));
359         else if( nbits < 768 )
360             tty_printf(_("keysize too small; 768 is smallest value allowed.\n"));
361         else if( nbits > 2048 ) {
362             tty_printf(_("Keysizes larger than 2048 are not suggested, because "
363                          "computations take REALLY long!\n"));
364             answer = tty_get(_("Are you sure, that you want this keysize? "));
365             tty_kill_prompt();
366             if( answer_is_yes(answer) ) {
367                 m_free(answer);
368                 tty_printf(_("Okay, but keep in mind that your monitor "
369                              "and keyboard radiation is also very vulnerable "
370                              "to attacks!\n"));
371                 break;
372             }
373             m_free(answer);
374         }
375         else
376             break;
377     }
378     tty_printf(_("Requested keysize is %u bits\n"), nbits );
379     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
380         nbits = ((nbits + 63) / 64) * 64;
381         tty_printf(_("rounded up to %u bits\n"), nbits );
382     }
383     else if( (nbits % 32) ) {
384         nbits = ((nbits + 31) / 32) * 32;
385         tty_printf(_("rounded up to %u bits\n"), nbits );
386     }
387
388   #ifdef TEST_UID
389     uid = m_alloc(strlen(TEST_UID)+1);
390     strcpy(uid, TEST_UID);
391   #else
392     tty_printf( _("\n"
393 "You need a User-ID to identify your key; the software constructs the user id\n"
394 "from Real Name, Comment and Email Address in this form:\n"
395 "    \"Heinrich Heine (Der Dichter) <heinrichh@uni-duesseldorf.de>\"\n\n") );
396     uid = NULL;
397     aname=acomment=amail=NULL;
398     for(;;) {
399         char *p;
400
401         if( !aname ) {
402             for(;;) {
403                 m_free(aname);
404                 aname = tty_get(_("Real name: "));
405                 trim_spaces(aname);
406                 tty_kill_prompt();
407                 if( strpbrk( aname, "<([])>" ) )
408                     tty_printf(_("Invalid character in name\n"));
409                 else if( isdigit(*aname) )
410                     tty_printf(_("Name may not start with a digit\n"));
411                 else if( strlen(aname) < 5 )
412                     tty_printf(_("Name must be at least 5 characters long\n"));
413                 else
414                     break;
415             }
416         }
417         if( !amail ) {
418             for(;;) {
419                 m_free(amail);
420                 amail = tty_get(_("Email address: "));
421                 trim_spaces(amail);
422                 strlwr(amail);
423                 tty_kill_prompt();
424                 if( !*amail )
425                     break;   /* no email address is okay */
426                 else if( strcspn( amail, "abcdefghijklmnopqrstuvwxyz_-.@" )
427                          || string_count_chr(amail,'@') != 1
428                          || *amail == '@'
429                          || amail[strlen(amail)-1] == '@'
430                          || amail[strlen(amail)-1] == '.'
431                          || strstr(amail, "..") )
432                     tty_printf(_("Not a valid email address\n"));
433                 else
434                     break;
435             }
436         }
437         if( !acomment ) {
438             for(;;) {
439                 m_free(acomment);
440                 acomment = tty_get(_("Comment: "));
441                 trim_spaces(acomment);
442                 tty_kill_prompt();
443                 if( !*acomment )
444                     break;   /* no comment is okay */
445                 else if( strpbrk( acomment, "()" ) )
446                     tty_printf(_("Invalid character in comment\n"));
447                 else
448                     break;
449             }
450         }
451
452         m_free(uid);
453         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
454         p = stpcpy(p, aname );
455         if( *acomment )
456             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
457         if( *amail )
458             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
459
460         /* append a warning if we do not have dev/random
461          * or it is switched into  quick testmode */
462         if( quick_random_gen(-1) )
463             strcpy(p, " (INSECURE!)" );
464
465
466         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
467         for(;;) {
468             answer = tty_get(_("Edit (N)ame, (C)omment, (E)mail or (O)kay? "));
469             tty_kill_prompt();
470             if( strlen(answer) > 1 )
471                 ;
472             else if( *answer == 'N' || *answer == 'n' ) {
473                 m_free(aname); aname = NULL;
474                 break;
475             }
476             else if( *answer == 'C' || *answer == 'c' ) {
477                 m_free(acomment); acomment = NULL;
478                 break;
479             }
480             else if( *answer == 'E' || *answer == 'e' ) {
481                 m_free(amail); amail = NULL;
482                 break;
483             }
484             else if( *answer == 'O' || *answer == 'o' ) {
485                 m_free(aname); aname = NULL;
486                 m_free(acomment); acomment = NULL;
487                 m_free(amail); amail = NULL;
488                 break;
489             }
490             m_free(answer);
491         }
492         m_free(answer);
493         if( !amail && !acomment && !amail )
494             break;
495         m_free(uid); uid = NULL;
496     }
497   #endif
498
499
500     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
501
502     dek = m_alloc_secure( sizeof *dek );
503     for(;;) {
504         dek->algo = CIPHER_ALGO_BLOWFISH;
505         rc = make_dek_from_passphrase( dek , 2 );
506         if( rc == -1 ) {
507             m_free(dek); dek = NULL;
508             tty_printf(_(
509             "You don't what a passphrase - this is probably a *bad* idea!\n"
510             "I will do it anyway.  You can change your passphrase at anytime,\n"
511             "using this program with the option \"--change-passphrase\"\n\n"));
512             break;
513         }
514         else if( rc == G10ERR_PASSPHRASE ) {
515             tty_printf(_("passphrase not correctly repeated; try again.\n"));
516         }
517         else if( rc ) {
518             m_free(dek); dek = NULL;
519             m_free(uid);
520             log_error("Error getting the passphrase: %s\n", g10_errstr(rc) );
521             return;
522         }
523         else
524             break; /* okay */
525     }
526
527
528     /* now check wether we a are allowed to write to the keyrings */
529     pub_fname = make_filename("~/.g10", "pubring.g10", NULL );
530     sec_fname = make_filename("~/.g10", "secring.g10", NULL );
531     if( opt.verbose ) {
532         tty_printf(_("writing public certificate to '%s'\n"), pub_fname );
533         tty_printf(_("writing secret certificate to '%s'\n"), sec_fname );
534     }
535
536     /* we create the packets as a tree of kbnodes. Because the structure
537      * we create is known in advance we simply generate a linked list
538      * The first packet is a comment packet, followed by the userid and
539      * the self signature.
540      */
541     pub_root = make_comment_node("#created by G10 pre-release " VERSION );
542     sec_root = make_comment_node("#created by G10 pre-release " VERSION );
543
544     tty_printf(_(
545 "We need to generate a lot of random bytes. It is a good idea to perform\n"
546 "some other action (work in another window, move the mouse, utilize the\n"
547 "network and the disks) during the prime generation; this gives the random\n"
548 "number generator a better chance to gain enough entropy.\n") );
549
550     if( algo == PUBKEY_ALGO_ELGAMAL )
551         rc = gen_elg(nbits, pub_root, sec_root, dek, &skc );
552   #ifdef ENABLE_RSA_KEYGEN
553     else if( algo == PUBKEY_ALGO_RSA )
554         rc = gen_rsa(nbits, pub_root, sec_root, dek, &skc );
555   #endif
556     else if( algo == PUBKEY_ALGO_DSA )
557         rc = gen_dsa(nbits, pub_root, sec_root, dek, &skc );
558     else
559         BUG();
560     if( !rc )
561         write_uid(pub_root, uid );
562     if( !rc )
563         write_uid(sec_root, uid );
564     if( !rc )
565         rc = write_selfsig(pub_root, pub_root, skc);
566     if( !rc )
567         rc = write_selfsig(sec_root, pub_root, skc);
568
569     if( !rc ) {
570         KBPOS pub_kbpos;
571         KBPOS sec_kbpos;
572         int rc1 = -1;
573         int rc2 = -1;
574
575         /* we can now write the certificates */
576         /* FIXME: should we check wether the user-id already exists? */
577
578         if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
579             if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
580                 log_error("can add keyblock file '%s'\n", pub_fname );
581                 rc = G10ERR_CREATE_FILE;
582             }
583             else if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
584                 log_error("can get keyblock handle for '%s'\n", pub_fname );
585                 rc = G10ERR_CREATE_FILE;
586             }
587         }
588         if( rc )
589             ;
590         else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
591             if( add_keyblock_resource( sec_fname, 1, 1 ) ) {
592                 log_error("can add keyblock file '%s'\n", sec_fname );
593                 rc = G10ERR_CREATE_FILE;
594             }
595             else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
596                 log_error("can get keyblock handle for '%s'\n", sec_fname );
597                 rc = G10ERR_CREATE_FILE;
598             }
599         }
600
601         if( rc )
602             ;
603         else if( (rc=rc1=lock_keyblock( &pub_kbpos )) )
604             log_error("can't lock public keyring: %s\n", g10_errstr(rc) );
605         else if( (rc=rc2=lock_keyblock( &sec_kbpos )) )
606             log_error("can't lock secret keyring: %s\n", g10_errstr(rc) );
607         else if( (rc=insert_keyblock( &pub_kbpos, pub_root )) )
608             log_error("can't write public key: %s\n", g10_errstr(rc) );
609         else if( (rc=insert_keyblock( &sec_kbpos, sec_root )) )
610             log_error("can't write secret key: %s\n", g10_errstr(rc) );
611         else {
612             tty_printf(_("public and secret key created and signed.\n") );
613         }
614
615         if( !rc1 )
616             unlock_keyblock( &pub_kbpos );
617         if( !rc2 )
618             unlock_keyblock( &sec_kbpos );
619     }
620
621
622     if( rc )
623         tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
624     release_kbnode( pub_root );
625     release_kbnode( sec_root );
626     if( skc ) /* the unprotected  secret certificate */
627         free_secret_cert(skc);
628     m_free(uid);
629     m_free(dek);
630     m_free(pub_fname);
631     m_free(sec_fname);
632 }
633