added some trust model stuff
[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         BUG(); /* 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         BUG();
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
153     elg_generate( &pk, &sk, nbits );
154
155     skc = m_alloc_clear( sizeof *skc );
156     pkc = m_alloc_clear( 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_clear( sizeof *skc );
220     pkc = m_alloc_clear( 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     KBNODE pub_root = NULL;
300     KBNODE sec_root = NULL;
301     PKT_secret_cert *skc = NULL;
302     DEK *dek = NULL;
303     int rc;
304     int algo;
305     const char *algo_name;
306     char *aname, *acomment, *amail;
307
308   #ifndef TEST_ALGO
309     if( opt.batch || opt.answer_yes || opt.answer_no )
310         log_fatal("Key generation can only be used in interactive mode\n");
311
312     tty_printf("Please select the algorithm to use:\n"
313                "   (1) ElGamal is the suggested one.\n"
314                "   (2) DSA can only be used for signatures.\n"
315            #ifdef ENABLE_RSA_KEYGEN
316                "   (3) RSA cannot be used in the U.S.\n"
317            #endif
318                );
319   #endif
320
321     for(;;) {
322       #ifdef TEST_ALGO
323         algo = TEST_ALGO;
324       #else
325         answer = tty_get("Your selection? (1,2"
326                                            #ifdef ENABLE_RSA_KEYGEN
327                                              ",3"
328                                            #endif
329                                              ") ");
330         tty_kill_prompt();
331         algo = *answer? atoi(answer): 1;
332         m_free(answer);
333       #endif
334         if( algo == 1 ) {
335             algo = PUBKEY_ALGO_ELGAMAL;
336             algo_name = "ElGamal";
337             break;
338         }
339         else if( algo == 2 ) {
340             algo = PUBKEY_ALGO_DSA;
341             algo_name = "DSA";
342             tty_printf("Sorry; DSA is not yet supported.\n");
343         }
344       #ifdef ENABLE_RSA_KEYGEN
345         else if( algo == 3 ) {
346             algo = PUBKEY_ALGO_RSA;
347             algo_name = "RSA";
348             break;
349         }
350       #endif
351     }
352
353
354
355     tty_printf("About to generate a new %s keypair.\n"
356           #ifndef TEST_NBITS
357                "              minimum keysize is  768 bits\n"
358                "              default keysize is 1024 bits\n"
359                "    highest suggested keysize is 2048 bits\n"
360           #endif
361                                                              , algo_name );
362     for(;;) {
363       #ifdef TEST_NBITS
364         nbits = TEST_NBITS;
365       #else
366         answer = tty_get("What keysize do you want? (1024) ");
367         tty_kill_prompt();
368         nbits = *answer? atoi(answer): 1024;
369         m_free(answer);
370       #endif
371         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
372             tty_printf("DSA does only allow keysizes from 512 to 1024\n");
373         else if( nbits < 768 )
374             tty_printf("keysize too small; 768 is smallest value allowed.\n");
375         else if( nbits > 2048 ) {
376             tty_printf("Keysizes larger than 2048 are not suggested, because "
377                        "computations take REALLY long!\n");
378             answer = tty_get("Are you sure, that you want this keysize? ");
379             tty_kill_prompt();
380             if( answer_is_yes(answer) ) {
381                 m_free(answer);
382                 tty_printf("Okay, but keep in mind that your monitor "
383                            "and keyboard radiation is also very vulnerable "
384                            "to attacks!\n");
385                 break;
386             }
387             m_free(answer);
388         }
389         else
390             break;
391     }
392     tty_printf("Requested keysize is %u bits\n", nbits );
393     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
394         nbits = ((nbits + 63) / 64) * 64;
395         tty_printf("rounded up to %u bits\n", nbits );
396     }
397     else if( (nbits % 32) ) {
398         nbits = ((nbits + 31) / 32) * 32;
399         tty_printf("rounded up to %u bits\n", nbits );
400     }
401
402   #ifdef TEST_UID
403     uid = m_alloc(strlen(TEST_UID)+1);
404     strcpy(uid, TEST_UID);
405   #else
406     tty_printf( "\n"
407 "You need a User-ID to identify your key; the software constructs the user id\n"
408 "from Real Name, Comment and Email Address in this form:\n"
409 "    \"Heinrich Heine (Der Dichter) <heinrichh@uni-duesseldorf.de>\"\n\n" );
410     uid = NULL;
411     aname=acomment=amail=NULL;
412     for(;;) {
413         char *p;
414
415         if( !aname ) {
416             for(;;) {
417                 m_free(aname);
418                 aname = tty_get("Real name: ");
419                 trim_spaces(aname);
420                 tty_kill_prompt();
421                 if( strpbrk( aname, "<([])>" ) )
422                     tty_printf("Invalid character in name\n");
423                 else if( isdigit(*aname) )
424                     tty_printf("Name may not start with a digit\n");
425                 else if( strlen(aname) < 5 )
426                     tty_printf("Name must be at least 5 characters long\n");
427                 else
428                     break;
429             }
430         }
431         if( !amail ) {
432             for(;;) {
433                 m_free(amail);
434                 amail = tty_get("Email address: ");
435                 trim_spaces(amail);
436                 strlwr(amail);
437                 tty_kill_prompt();
438                 if( !*amail )
439                     break;   /* no email address is okay */
440                 else if( strcspn( amail, "abcdefghijklmnopqrstuvwxyz_-.@" )
441                          || string_count_chr(amail,'@') != 1
442                          || *amail == '@'
443                          || amail[strlen(amail)-1] == '@'
444                          || amail[strlen(amail)-1] == '.'
445                          || strstr(amail, "..") )
446                     tty_printf("Not a valid email address\n");
447                 else
448                     break;
449             }
450         }
451         if( !acomment ) {
452             for(;;) {
453                 m_free(acomment);
454                 acomment = tty_get("Comment: ");
455                 trim_spaces(acomment);
456                 tty_kill_prompt();
457                 if( !*acomment )
458                     break;   /* no comment is okay */
459                 else if( strpbrk( acomment, "()" ) )
460                     tty_printf("Invalid character in comment\n");
461                 else
462                     break;
463             }
464         }
465
466         m_free(uid);
467         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
468         p = stpcpy(p, aname );
469         if( *acomment )
470             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
471         if( *amail )
472             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
473
474         /* append a warning if we do not have dev/random
475          * or it is switched into  quick testmode */
476       #ifdef HAVE_DEV_RANDOM
477         if( quick_random_gen(-1) )
478       #endif
479             strcpy(p, " (INSECURE!)" );
480
481
482         tty_printf("You selected this USER-ID:\n    \"%s\"\n\n", uid);
483         for(;;) {
484             answer = tty_get("Edit (N)ame, (C)omment, (E)mail or (O)kay? ");
485             tty_kill_prompt();
486             if( strlen(answer) > 1 )
487                 ;
488             else if( *answer == 'N' || *answer == 'n' ) {
489                 m_free(aname); aname = NULL;
490                 break;
491             }
492             else if( *answer == 'C' || *answer == 'c' ) {
493                 m_free(acomment); acomment = NULL;
494                 break;
495             }
496             else if( *answer == 'E' || *answer == 'e' ) {
497                 m_free(amail); amail = NULL;
498                 break;
499             }
500             else if( *answer == 'O' || *answer == 'o' ) {
501                 m_free(aname); aname = NULL;
502                 m_free(acomment); acomment = NULL;
503                 m_free(amail); amail = NULL;
504                 break;
505             }
506             m_free(answer);
507         }
508         m_free(answer);
509         if( !amail && !acomment && !amail )
510             break;
511         m_free(uid); uid = NULL;
512     }
513   #endif
514
515
516     tty_printf( "You need a Passphrase to protect your secret key.\n\n" );
517
518     dek = m_alloc_secure( sizeof *dek );
519     for(;;) {
520         dek->algo = CIPHER_ALGO_BLOWFISH;
521         rc = make_dek_from_passphrase( dek , 2 );
522         if( rc == -1 ) {
523             m_free(dek); dek = NULL;
524             tty_printf(
525             "You don't what a passphrase - this is probably a *bad* idea!\n"
526             "I will do it anyway.  You can change your passphrase at anytime,\n"
527             "using this program with the option \"--change-passphrase\"\n\n" );
528             break;
529         }
530         else if( rc == G10ERR_PASSPHRASE ) {
531             tty_printf("passphrase not correctly repeated; try again.\n");
532         }
533         else if( rc ) {
534             m_free(dek); dek = NULL;
535             m_free(uid);
536             log_error("Error getting the passphrase: %s\n", g10_errstr(rc) );
537             return;
538         }
539         else
540             break; /* okay */
541     }
542
543
544     /* now check wether we a are allowed to write to the keyrings */
545     pub_fname = make_filename("~/.g10", "pubring.g10", NULL );
546     sec_fname = make_filename("~/.g10", "secring.g10", NULL );
547     if( opt.verbose ) {
548         tty_printf("writing public certificate to '%s'\n", pub_fname );
549         tty_printf("writing secret certificate to '%s'\n", sec_fname );
550     }
551
552     /* we create the packets as a tree of kbnodes. Because the structure
553      * we create is known in advance we simply generate a linked list
554      * The first packet is a comment packet, followed by the userid and
555      * the self signature.
556      */
557     pub_root = make_comment_node("#created by G10 pre-release " VERSION );
558     sec_root = make_comment_node("#created by G10 pre-release " VERSION );
559
560     tty_printf(
561 "We need to generate a lot of random bytes. It is a good idea to perform\n"
562 "some other action (work in another window, move the mouse, utilize the\n"
563 "network and the disks) during the prime generation; this gives the random\n"
564 "number generator a better chance to gain enough entropy.\n" );
565
566     if( algo == PUBKEY_ALGO_ELGAMAL )
567         rc = gen_elg(nbits, pub_root, sec_root, dek, &skc );
568   #ifdef ENABLE_RSA_KEYGEN
569     else if( algo == PUBKEY_ALGO_RSA )
570         rc = gen_rsa(nbits, pub_io, sec_io, dek, &skc );
571   #endif
572     else if( algo == PUBKEY_ALGO_DSA )
573         rc = gen_dsa(nbits, pub_root, sec_root, dek, &skc );
574     else
575         BUG();
576     if( !rc )
577         write_uid(pub_root, uid );
578     if( !rc )
579         write_uid(sec_root, uid );
580     if( !rc )
581         rc = write_selfsig(pub_root, pub_root, skc);
582     if( !rc )
583         rc = write_selfsig(sec_root, pub_root, skc);
584
585     if( !rc ) {
586         KBPOS pub_kbpos;
587         KBPOS sec_kbpos;
588         int rc1 = -1;
589         int rc2 = -1;
590
591         /* we can now write the certificates */
592         /* FIXME: should we check wether the user-id already exists? */
593
594         if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
595             if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
596                 log_error("can add keyblock file '%s'\n", pub_fname );
597                 rc = G10ERR_CREATE_FILE;
598             }
599             else if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
600                 log_error("can get keyblock handle for '%s'\n", pub_fname );
601                 rc = G10ERR_CREATE_FILE;
602             }
603         }
604         if( rc )
605             ;
606         else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
607             if( add_keyblock_resource( sec_fname, 1, 1 ) ) {
608                 log_error("can add keyblock file '%s'\n", sec_fname );
609                 rc = G10ERR_CREATE_FILE;
610             }
611             else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
612                 log_error("can get keyblock handle for '%s'\n", sec_fname );
613                 rc = G10ERR_CREATE_FILE;
614             }
615         }
616
617         if( rc )
618             ;
619         else if( (rc=rc1=lock_keyblock( &pub_kbpos )) )
620             log_error("can't lock public keyring: %s\n", g10_errstr(rc) );
621         else if( (rc=rc2=lock_keyblock( &sec_kbpos )) )
622             log_error("can't lock secret keyring: %s\n", g10_errstr(rc) );
623         else if( (rc=insert_keyblock( &pub_kbpos, pub_root )) )
624             log_error("can't write public key: %s\n", g10_errstr(rc) );
625         else if( (rc=insert_keyblock( &sec_kbpos, sec_root )) )
626             log_error("can't write secret key: %s\n", g10_errstr(rc) );
627         else {
628             tty_printf("public and secret key created and signed.\n" );
629         }
630
631         if( !rc1 )
632             unlock_keyblock( &pub_kbpos );
633         if( !rc2 )
634             unlock_keyblock( &sec_kbpos );
635     }
636
637
638     if( rc )
639         tty_printf("Key generation failed: %s\n", g10_errstr(rc) );
640     release_kbnode( pub_root );
641     release_kbnode( sec_root );
642     if( skc ) /* the unprotected  secret certificate */
643         free_secret_cert(skc);
644     m_free(uid);
645     m_free(dek);
646     m_free(pub_fname);
647     m_free(sec_fname);
648 }
649