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