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