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