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