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