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