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