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