patchlevel 2
[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 <errno.h>
26 #include <assert.h>
27 #include "util.h"
28 #include "main.h"
29 #include "packet.h"
30 #include "cipher.h"
31 #include "ttyio.h"
32 #include "options.h"
33 #include "keydb.h"
34
35 #if 0
36   #define TEST_ALGO  1
37   #define TEST_NBITS 256
38   #define TEST_UID   "Karl Test"
39 #endif
40
41 #if defined(HAVE_RSA_CIPHER) && 0
42   #define ENABLE_RSA_KEYGEN 1
43 #endif
44
45
46 static u16
47 checksum_u16( unsigned n )
48 {
49     u16 a;
50
51     a  = (n >> 8) & 0xff;
52     a |= n & 0xff;
53     return a;
54 }
55
56 static u16
57 checksum( byte *p, unsigned n )
58 {
59     u16 a;
60
61     for(a=0; n; n-- )
62         a += *p++;
63     return a;
64 }
65
66 static u16
67 checksum_mpi( MPI a )
68 {
69     u16 csum;
70     byte *buffer;
71     unsigned nbytes;
72
73     buffer = mpi_get_buffer( a, &nbytes, NULL );
74     csum = checksum_u16( nbytes*8 );
75     csum += checksum( buffer, nbytes );
76     m_free( buffer );
77     return csum;
78 }
79
80
81
82 static void
83 write_uid( KBNODE root, const char *s )
84 {
85     PACKET *pkt = m_alloc_clear(sizeof *pkt );
86     size_t n = strlen(s);
87
88     pkt->pkttype = PKT_USER_ID;
89     pkt->pkt.user_id = m_alloc( sizeof *pkt->pkt.user_id + n - 1 );
90     pkt->pkt.user_id->len = n;
91     strcpy(pkt->pkt.user_id->name, s);
92     add_kbnode( root, new_kbnode( pkt ) );
93 }
94
95
96 static int
97 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_cert *skc )
98 {
99     PACKET *pkt;
100     PKT_signature *sig;
101     PKT_user_id *uid;
102     int rc=0;
103     KBNODE kbctx, node;
104     PKT_public_cert *pkc;
105
106     if( opt.verbose )
107         log_info("writing self signature\n");
108
109     /* get the uid packet from the tree */
110     for( kbctx=NULL; (node=walk_kbtree( root, &kbctx)) ; ) {
111         if( node->pkt->pkttype == PKT_USER_ID )
112             break;
113     }
114     if( !node )
115         log_bug(NULL); /* no user id packet in tree */
116     uid = node->pkt->pkt.user_id;
117     /* get the pkc packet from the pub_tree */
118     for( kbctx=NULL; (node=walk_kbtree( pub_root, &kbctx)) ; ) {
119         if( node->pkt->pkttype == PKT_PUBLIC_CERT )
120             break;
121     }
122     if( !node )
123         log_bug(NULL);
124     pkc = node->pkt->pkt.public_cert;
125
126     /* and make the signature */
127     rc = make_keysig_packet( &sig, pkc, uid, skc, 0x13, DIGEST_ALGO_RMD160 );
128     if( rc ) {
129         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
130         return rc;
131     }
132
133     pkt = m_alloc_clear( sizeof *pkt );
134     pkt->pkttype = PKT_SIGNATURE;
135     pkt->pkt.signature = sig;
136     add_kbnode( root, new_kbnode( pkt ) );
137     return rc;
138 }
139
140
141 static int
142 gen_elg(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
143         PKT_secret_cert **ret_skc )
144 {
145     int rc;
146     PACKET *pkt;
147     PKT_secret_cert *skc;
148     PKT_public_cert *pkc;
149     ELG_public_key pk;
150     ELG_secret_key sk;
151     unsigned nbytes;
152
153     elg_generate( &pk, &sk, nbits );
154
155     skc = m_alloc( sizeof *skc );
156     pkc = m_alloc( 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( sizeof *skc );
220     pkc = m_alloc( 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     IOBUF pub_io = NULL;
300     IOBUF sec_io = NULL;
301     KBNODE pub_root = NULL;
302     KBNODE sec_root = NULL;
303     PKT_secret_cert *skc = NULL;
304     DEK *dek = NULL;
305     int rc;
306     int algo;
307     const char *algo_name;
308     char *aname, *acomment, *amail;
309
310   #ifndef TEST_ALGO
311     if( opt.batch || opt.answer_yes || opt.answer_no )
312         log_fatal("Key generation can only be used in interactive mode\n");
313
314     tty_printf("Please select the algorithm to use:\n"
315                "   (1) ElGamal is the suggested one.\n"
316                "   (2) DSA can only be used for signatures.\n"
317            #ifdef ENABLE_RSA_KEYGEN
318                "   (3) RSA cannot be used in the U.S.\n"
319            #endif
320                );
321   #endif
322
323     for(;;) {
324       #ifdef TEST_ALGO
325         algo = TEST_ALGO;
326       #else
327         answer = tty_get("Your selection? (1,2"
328                                            #ifdef ENABLE_RSA_KEYGEN
329                                              ",3"
330                                            #endif
331                                              ") ");
332         tty_kill_prompt();
333         algo = *answer? atoi(answer): 1;
334         m_free(answer);
335       #endif
336         if( algo == 1 ) {
337             algo = PUBKEY_ALGO_ELGAMAL;
338             algo_name = "ElGamal";
339             break;
340         }
341         else if( algo == 2 ) {
342             algo = PUBKEY_ALGO_DSA;
343             algo_name = "DSA";
344             tty_printf("Sorry; DSA is not yet supported.\n");
345         }
346       #ifdef ENABLE_RSA_KEYGEN
347         else if( algo == 3 ) {
348             algo = PUBKEY_ALGO_RSA;
349             algo_name = "RSA";
350             break;
351         }
352       #endif
353     }
354
355
356
357     tty_printf("About to generate a new %s keypair.\n"
358           #ifndef TEST_NBITS
359                "              minimum keysize is  768 bits\n"
360                "              default keysize is 1024 bits\n"
361                "    highest suggested keysize is 2048 bits\n"
362           #endif
363                                                              , algo_name );
364     for(;;) {
365       #ifdef TEST_NBITS
366         nbits = TEST_NBITS;
367       #else
368         answer = tty_get("What keysize do you want? (1024) ");
369         tty_kill_prompt();
370         nbits = *answer? atoi(answer): 1024;
371         m_free(answer);
372       #endif
373         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
374             tty_printf("DSA does only allow keysizes from 512 to 1024\n");
375         else if( nbits < 768 )
376             tty_printf("keysize too small; 768 is smallest value allowed.\n");
377         else if( nbits > 2048 ) {
378             tty_printf("Keysizes larger than 2048 are not suggested, because "
379                        "computations take REALLY long!\n");
380             answer = tty_get("Are you sure, that you want this keysize? ");
381             tty_kill_prompt();
382             if( answer_is_yes(answer) ) {
383                 m_free(answer);
384                 tty_printf("Okay, but keep in mind that your monitor "
385                            "and keyboard radiation is also very vulnerable "
386                            "to attacks!\n");
387                 break;
388             }
389             m_free(answer);
390         }
391         else
392             break;
393     }
394     tty_printf("Requested keysize is %u bits\n", nbits );
395     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
396         nbits = ((nbits + 63) / 64) * 64;
397         tty_printf("rounded up to %u bits\n", nbits );
398     }
399     else if( (nbits % 32) ) {
400         nbits = ((nbits + 31) / 32) * 32;
401         tty_printf("rounded up to %u bits\n", nbits );
402     }
403
404   #ifdef TEST_UID
405     uid = m_alloc(strlen(TEST_UID)+1);
406     strcpy(uid, TEST_UID);
407   #else
408     tty_printf( "\n"
409 "You need a User-ID to identify your key; the software constructs the user id\n"
410 "from Real Name, Comment and Email Address in this form:\n"
411 "    \"Heinrich Heine (Der Dichter) <heinrichh@uni-duesseldorf.de>\"\n" );
412     uid = NULL;
413     aname=acomment=amail=NULL;
414     for(;;) {
415         char *p;
416
417         if( !aname ) {
418             for(;;) {
419                 m_free(aname);
420                 aname = tty_get("Real name: ");
421                 trim_spaces(aname);
422                 tty_kill_prompt();
423                 if( strpbrk( aname, "<([])>" ) )
424                     tty_printf("Invalid character in name\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)+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         tty_printf("You selected this USER-ID:\n    \"%s\"\n\n", uid);
475         for(;;) {
476             answer = tty_get("Edit (N)ame, (C)omment, (E)mail or (O)kay? ");
477             tty_kill_prompt();
478             if( strlen(answer) > 1 )
479                 ;
480             else if( *answer == 'N' || *answer == 'n' ) {
481                 m_free(aname); aname = NULL;
482                 break;
483             }
484             else if( *answer == 'C' || *answer == 'c' ) {
485                 m_free(acomment); acomment = NULL;
486                 break;
487             }
488             else if( *answer == 'E' || *answer == 'e' ) {
489                 m_free(amail); amail = NULL;
490                 break;
491             }
492             else if( *answer == 'O' || *answer == 'o' ) {
493                 m_free(aname); aname = NULL;
494                 m_free(acomment); acomment = NULL;
495                 m_free(amail); amail = NULL;
496                 break;
497             }
498             m_free(answer);
499         }
500         m_free(answer);
501         if( !amail && !acomment && !amail )
502             break;
503         m_free(uid); uid = NULL;
504     }
505   #endif
506
507
508     tty_printf( "You need a Passphrase to protect your secret key.\n\n" );
509
510     dek = m_alloc_secure( sizeof *dek );
511     for(;;) {
512         dek->algo = CIPHER_ALGO_BLOWFISH;
513         rc = make_dek_from_passphrase( dek , 2 );
514         if( rc == -1 ) {
515             m_free(dek); dek = NULL;
516             tty_printf(
517             "You don't what a passphrase - this is probably a *bad* idea!\n"
518             "I will do it anyway.  You can change your passphrase at anytime,\n"
519             "using this program with the option \"--change-passphrase\"\n\n" );
520             break;
521         }
522         else if( rc == G10ERR_PASSPHRASE ) {
523             tty_printf("passphrase not correctly repeated; try again.\n");
524         }
525         else if( rc ) {
526             m_free(dek); dek = NULL;
527             m_free(uid);
528             log_error("Error getting the passphrase: %s\n", g10_errstr(rc) );
529             return;
530         }
531         else
532             break; /* okay */
533     }
534
535
536     /* now check wether we a are allowed to write to the keyrings */
537     pub_fname = make_filename("~/.g10", "pubring.g10", NULL );
538     sec_fname = make_filename("~/.g10", "secring.g10", NULL );
539     if( opt.verbose ) {
540         tty_printf("writing public certificate to '%s'\n", pub_fname );
541         tty_printf("writing secret certificate to '%s'\n", sec_fname );
542     }
543
544     /* we create the packets as a tree of kbnodes. Because the structure
545      * we create is known in advance we simply generate a linked list
546      * The first packet is a comment packet, followed by the userid and
547      * the self signature.
548      */
549     pub_root = make_comment_node("#created by G10 pre-release " VERSION );
550     sec_root = make_comment_node("#created by G10 pre-release " VERSION );
551
552     tty_printf(
553 "We need to generate a lot of random bytes. It is a good idea to perform\n"
554 "some other action (work in another window, move the mouse, utilize the\n"
555 "network and the disks) during the prime generation; this gives the random\n"
556 "number generator a better chance to gain enough entropy.\n" );
557
558     if( algo == PUBKEY_ALGO_ELGAMAL )
559         rc = gen_elg(nbits, pub_root, sec_root, dek, &skc );
560   #ifdef ENABLE_RSA_KEYGEN
561     else if( algo == PUBKEY_ALGO_RSA )
562         rc = gen_rsa(nbits, pub_io, sec_io, dek, &skc );
563   #endif
564     else if( algo == PUBKEY_ALGO_DSA )
565         rc = gen_dsa(nbits, pub_root, sec_root, dek, &skc );
566     else
567         log_bug(NULL);
568     if( !rc )
569         write_uid(pub_root, uid );
570     if( !rc )
571         write_uid(sec_root, uid );
572     if( !rc )
573         rc = write_selfsig(pub_root, pub_root, skc);
574     if( !rc )
575         rc = write_selfsig(sec_root, pub_root, skc);
576
577     if( !rc ) {
578         KBPOS pub_kbpos;
579         KBPOS sec_kbpos;
580         int rc1 = -1;
581         int rc2 = -1;
582
583         /* we can now write the certificates */
584         /* FIXME: should we check wether the user-id already exists? */
585
586         if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
587             if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
588                 log_error("can add keyblock file '%s'\n", pub_fname );
589                 rc = G10ERR_CREATE_FILE;
590             }
591             else if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
592                 log_error("can get keyblock handle for '%s'\n", pub_fname );
593                 rc = G10ERR_CREATE_FILE;
594             }
595         }
596         if( rc )
597             ;
598         else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
599             if( add_keyblock_resource( sec_fname, 1, 1 ) ) {
600                 log_error("can add keyblock file '%s'\n", sec_fname );
601                 rc = G10ERR_CREATE_FILE;
602             }
603             else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
604                 log_error("can get keyblock handle for '%s'\n", sec_fname );
605                 rc = G10ERR_CREATE_FILE;
606             }
607         }
608
609         if( rc )
610             ;
611         else if( (rc=rc1=lock_keyblock( &pub_kbpos )) )
612             log_error("can't lock public keyring: %s\n", g10_errstr(rc) );
613         else if( (rc=rc2=lock_keyblock( &sec_kbpos )) )
614             log_error("can't lock secret keyring: %s\n", g10_errstr(rc) );
615         else if( (rc=insert_keyblock( &pub_kbpos, pub_root )) )
616             log_error("can't write public key: %s\n", g10_errstr(rc) );
617         else if( (rc=insert_keyblock( &sec_kbpos, sec_root )) )
618             log_error("can't write secret key: %s\n", g10_errstr(rc) );
619         else {
620             tty_printf("public and secret key created and signed.\n" );
621         }
622
623         if( !rc1 )
624             unlock_keyblock( &pub_kbpos );
625         if( !rc2 )
626             unlock_keyblock( &sec_kbpos );
627     }
628
629
630     if( rc )
631         tty_printf("Key generation failed: %s\n", g10_errstr(rc) );
632     release_kbnode( pub_root );
633     release_kbnode( sec_root );
634     if( skc ) /* the unprotected  secret certificate */
635         free_secret_cert(skc);
636     m_free(uid);
637     m_free(dek);
638     m_free(pub_fname);
639     m_free(sec_fname);
640 }
641