add DSA key generation
[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 /****************
228  * Generate a DSA key
229  */
230 static int
231 gen_dsa(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
232             STRING2KEY *s2k, PKT_secret_cert **ret_skc, u16 valid_days )
233 {
234     int rc;
235     int i;
236     PACKET *pkt;
237     PKT_secret_cert *skc;
238     PKT_public_cert *pkc;
239     DSA_public_key pk;
240     DSA_secret_key sk;
241     MPI *factors;
242
243     if( nbits > 1024 )
244         nbits = 1024;
245
246     dsa_generate( &pk, &sk, nbits, &factors );
247
248     skc = m_alloc_clear( sizeof *skc );
249     pkc = m_alloc_clear( sizeof *pkc );
250     skc->timestamp = pkc->timestamp = make_timestamp();
251     skc->version = pkc->version = 4;
252     /* valid days are not stored in the packet, but it is
253      * used here to put it into the signature.
254      */
255     skc->valid_days = pkc->valid_days = valid_days;
256     skc->pubkey_algo = pkc->pubkey_algo = PUBKEY_ALGO_DSA;
257                        pkc->d.dsa.p = pk.p;
258                        pkc->d.dsa.q = pk.q;
259                        pkc->d.dsa.g = pk.g;
260                        pkc->d.dsa.y = pk.y;
261     skc->d.dsa.p = sk.p;
262     skc->d.dsa.q = sk.q;
263     skc->d.dsa.g = sk.g;
264     skc->d.dsa.y = sk.y;
265     skc->d.dsa.x = sk.x;
266     skc->is_protected = 0;
267     skc->protect.algo = 0;
268
269     skc->csum = checksum_mpi( skc->d.dsa.x );
270     /* return an unprotected version of the skc */
271     *ret_skc = copy_secret_cert( NULL, skc );
272
273     if( dek ) {
274         skc->protect.algo = dek->algo;
275         skc->protect.s2k = *s2k;
276         rc = protect_secret_key( skc, dek );
277         if( rc ) {
278             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
279             free_public_cert(pkc);
280             free_secret_cert(skc);
281             return rc;
282         }
283     }
284
285     pkt = m_alloc_clear(sizeof *pkt);
286     pkt->pkttype = PKT_PUBLIC_CERT;
287     pkt->pkt.public_cert = pkc;
288     add_kbnode(pub_root, new_kbnode( pkt ));
289
290     /* don't know whether it makes sense to have the factors, so for now
291      * we store them in the secret keyring (but they are not secret)
292      * p = 2 * q * f1 * f2 * ... * fn
293      * We store only f1 to f_n-1 - fn can be calculated because p and q
294      * are known.
295      */
296     pkt = m_alloc_clear(sizeof *pkt);
297     pkt->pkttype = PKT_SECRET_CERT;
298     pkt->pkt.secret_cert = skc;
299     add_kbnode(sec_root, new_kbnode( pkt ));
300     for(i=1; factors[i]; i++ )  /* the first one is q */
301         add_kbnode( sec_root,
302                     make_mpi_comment_node("#:DSA_factor:", factors[i] ));
303
304     return 0;
305 }
306
307
308
309 /****************
310  * check valid days:
311  * return 0 on error or the multiplier
312  */
313 static int
314 check_valid_days( const char *s )
315 {
316     if( !isdigit(*s) )
317         return 0;
318     for( s++; *s; s++)
319         if( !isdigit(*s) )
320             break;
321     if( !*s )
322         return 1;
323     if( s[1] )
324         return 0; /* e.g. "2323wc" */
325     if( *s == 'd' || *s == 'D' )
326         return 1;
327     if( *s == 'w' || *s == 'W' )
328         return 7;
329     if( *s == 'm' || *s == 'M' )
330         return 30;
331     if( *s == 'y' || *s == 'Y' )
332         return 365;
333     return 0;
334 }
335
336
337 /****************
338  * Generate a keypair
339  */
340 void
341 generate_keypair()
342 {
343     char *answer;
344     unsigned nbits;
345     char *pub_fname = NULL;
346     char *sec_fname = NULL;
347     char *uid = NULL;
348     KBNODE pub_root = NULL;
349     KBNODE sec_root = NULL;
350     PKT_secret_cert *skc = NULL;
351     DEK *dek = NULL;
352     STRING2KEY *s2k;
353     int rc;
354     int algo;
355     const char *algo_name;
356     char *aname, *acomment, *amail;
357     int valid_days=0;
358
359     if( opt.batch || opt.answer_yes || opt.answer_no ) {
360         log_error(_("Key generation can only be used in interactive mode\n"));
361         return;
362     }
363
364     tty_printf(_("Please select the algorithm to use:\n"
365                  "   (1) ElGamal is the suggested one.\n"
366                  "   (2) DSA can only be used for signatures.\n"));
367   #ifdef ENABLE_RSA_KEYGEN
368     tty_printf(_("   (3) RSA cannot be used in the U.S.\n"));
369   #endif
370
371     for(;;) {
372       #ifdef ENABLE_RSA_KEYGEN
373         answer = tty_get(_("Your selection? (1,2,3) "));
374       #else
375         answer = tty_get(_("Your selection? (1,2) "));
376       #endif
377         tty_kill_prompt();
378         algo = *answer? atoi(answer): 1;
379         m_free(answer);
380         if( algo == 1 ) {
381             algo = PUBKEY_ALGO_ELGAMAL;
382             algo_name = "ElGamal";
383             break;
384         }
385         else if( algo == 2 ) {
386             algo = PUBKEY_ALGO_DSA;
387             algo_name = "DSA";
388             break;
389         }
390       #ifdef ENABLE_RSA_KEYGEN
391         else if( algo == 3 ) {
392             algo = PUBKEY_ALGO_RSA;
393             algo_name = "RSA";
394             break;
395         }
396       #endif
397     }
398
399
400
401     tty_printf(_("About to generate a new %s keypair.\n"
402                  "              minimum keysize is  768 bits\n"
403                  "              default keysize is 1024 bits\n"
404                  "    highest suggested keysize is 2048 bits\n"), algo_name );
405     for(;;) {
406         answer = tty_get(_("What keysize do you want? (1024) "));
407         tty_kill_prompt();
408         nbits = *answer? atoi(answer): 1024;
409         m_free(answer);
410         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
411             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
412         else if( nbits < 768 )
413             tty_printf(_("keysize too small; 768 is smallest value allowed.\n"));
414         else if( nbits > 2048 ) {
415             tty_printf(_("Keysizes larger than 2048 are not suggested, because "
416                          "computations take REALLY long!\n"));
417             answer = tty_get(_("Are you sure, that you want this keysize? "));
418             tty_kill_prompt();
419             if( answer_is_yes(answer) ) {
420                 m_free(answer);
421                 tty_printf(_("Okay, but keep in mind that your monitor "
422                              "and keyboard radiation is also very vulnerable "
423                              "to attacks!\n"));
424                 break;
425             }
426             m_free(answer);
427         }
428         else if( nbits > 1536 ) {
429             answer = tty_get(_("Do you really need such a large keysize? "));
430             tty_kill_prompt();
431             if( answer_is_yes(answer) ) {
432                 m_free(answer);
433                 break;
434             }
435             m_free(answer);
436         }
437         else
438             break;
439     }
440     tty_printf(_("Requested keysize is %u bits\n"), nbits );
441     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
442         nbits = ((nbits + 63) / 64) * 64;
443         tty_printf(_("rounded up to %u bits\n"), nbits );
444     }
445     else if( (nbits % 32) ) {
446         nbits = ((nbits + 31) / 32) * 32;
447         tty_printf(_("rounded up to %u bits\n"), nbits );
448     }
449
450     tty_printf(_("Please specify how long the key should be valid.\n"
451                  "         0 = key does not expire\n"
452                  "      <n>  = key expires in n days\n"
453                  "      <n>w = key expires in n weeks\n"
454                  "      <n>m = key expires in n months\n"
455                  "      <n>y = key expires in n years\n"));
456     /* Note: The elgamal subkey for DSA has no exiration date because
457      * is must be signed with the DSA key and this one has the expiration
458      * date */
459
460     answer = NULL;
461     for(;;) {
462         int mult;
463
464         m_free(answer);
465         answer = tty_get(_("Key is valid for? (0) "));
466         tty_kill_prompt();
467         trim_spaces(answer);
468         if( !*answer )
469             valid_days = 0;
470         else if( (mult=check_valid_days(answer)) ) {
471             valid_days = atoi(answer) * mult;
472             if( valid_days < 0 || valid_days > 32767 )
473                 valid_days = 0;
474         }
475         else {
476             tty_printf(_("invalid value\n"));
477             continue;
478         }
479
480         if( !valid_days )
481             tty_printf(_("Key does not expire at all\n"));
482         else {
483             tty_printf(_("Key expires at %s\n"), strtimestamp(
484                        add_days_to_timestamp( make_timestamp(), valid_days )));
485         }
486
487         m_free(answer);
488         answer = tty_get(_("Is this correct (y/n)? "));
489         tty_kill_prompt();
490         if( answer_is_yes(answer) )
491             break;
492     }
493     m_free(answer);
494
495
496
497     tty_printf( _("\n"
498 "You need a User-ID to identify your key; the software constructs the user id\n"
499 "from Real Name, Comment and Email Address in this form:\n"
500 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
501     uid = NULL;
502     aname=acomment=amail=NULL;
503     for(;;) {
504         char *p;
505
506         if( !aname ) {
507             for(;;) {
508                 m_free(aname);
509                 aname = tty_get(_("Real name: "));
510                 trim_spaces(aname);
511                 tty_kill_prompt();
512                 if( strpbrk( aname, "<([])>" ) )
513                     tty_printf(_("Invalid character in name\n"));
514                 else if( isdigit(*aname) )
515                     tty_printf(_("Name may not start with a digit\n"));
516                 else if( strlen(aname) < 5 )
517                     tty_printf(_("Name must be at least 5 characters long\n"));
518                 else
519                     break;
520             }
521         }
522         if( !amail ) {
523             for(;;) {
524                 m_free(amail);
525                 amail = tty_get(_("Email address: "));
526                 trim_spaces(amail);
527                 strlwr(amail);
528                 tty_kill_prompt();
529                 if( !*amail )
530                     break;   /* no email address is okay */
531                 else if( strcspn( amail, "abcdefghijklmnopqrstuvwxyz_-.@" )
532                          || string_count_chr(amail,'@') != 1
533                          || *amail == '@'
534                          || amail[strlen(amail)-1] == '@'
535                          || amail[strlen(amail)-1] == '.'
536                          || strstr(amail, "..") )
537                     tty_printf(_("Not a valid email address\n"));
538                 else
539                     break;
540             }
541         }
542         if( !acomment ) {
543             for(;;) {
544                 m_free(acomment);
545                 acomment = tty_get(_("Comment: "));
546                 trim_spaces(acomment);
547                 tty_kill_prompt();
548                 if( !*acomment )
549                     break;   /* no comment is okay */
550                 else if( strpbrk( acomment, "()" ) )
551                     tty_printf(_("Invalid character in comment\n"));
552                 else
553                     break;
554             }
555         }
556
557         m_free(uid);
558         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
559         p = stpcpy(p, aname );
560         if( *acomment )
561             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
562         if( *amail )
563             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
564
565         /* append a warning if we do not have dev/random
566          * or it is switched into  quick testmode */
567         if( quick_random_gen(-1) )
568             strcpy(p, " (INSECURE!)" );
569
570
571         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
572         /* fixme: add a warning if this user-id already exists */
573         for(;;) {
574             answer = tty_get(_("Edit (N)ame, (C)omment, (E)mail or (O)kay? "));
575             tty_kill_prompt();
576             if( strlen(answer) > 1 )
577                 ;
578             else if( *answer == 'N' || *answer == 'n' ) {
579                 m_free(aname); aname = NULL;
580                 break;
581             }
582             else if( *answer == 'C' || *answer == 'c' ) {
583                 m_free(acomment); acomment = NULL;
584                 break;
585             }
586             else if( *answer == 'E' || *answer == 'e' ) {
587                 m_free(amail); amail = NULL;
588                 break;
589             }
590             else if( *answer == 'O' || *answer == 'o' ) {
591                 m_free(aname); aname = NULL;
592                 m_free(acomment); acomment = NULL;
593                 m_free(amail); amail = NULL;
594                 break;
595             }
596             m_free(answer);
597         }
598         m_free(answer);
599         if( !amail && !acomment && !amail )
600             break;
601         m_free(uid); uid = NULL;
602     }
603
604
605     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
606
607     s2k = m_alloc_secure( sizeof *s2k );
608     for(;;) {
609         s2k->mode = 1;
610         s2k->hash_algo = DIGEST_ALGO_RMD160;
611         dek = passphrase_to_dek( NULL, CIPHER_ALGO_BLOWFISH, s2k, 2 );
612         if( !dek ) {
613             tty_printf(_("passphrase not correctly repeated; try again.\n"));
614         }
615         else if( !dek->keylen ) {
616             m_free(dek); dek = NULL;
617             m_free(s2k); s2k = NULL;
618             tty_printf(_(
619             "You don't want a passphrase - this is probably a *bad* idea!\n"
620             "I will do it anyway.  You can change your passphrase at any time,\n"
621             "using this program with the option \"--change-passphrase\"\n\n"));
622             break;
623         }
624         else
625             break; /* okay */
626     }
627
628
629     /* now check whether we are allowed to write to the keyrings */
630     pub_fname = make_filename(opt.homedir, "pubring.gpg", NULL );
631     sec_fname = make_filename(opt.homedir, "secring.gpg", NULL );
632     if( opt.verbose ) {
633         tty_printf(_("writing public certificate to '%s'\n"), pub_fname );
634         tty_printf(_("writing secret certificate to '%s'\n"), sec_fname );
635     }
636
637     /* we create the packets as a tree of kbnodes. Because the structure
638      * we create is known in advance we simply generate a linked list
639      * The first packet is a dummy comment packet which we flag
640      * as deleted.  The very first packet must always be a CERT packet.
641      */
642     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
643     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
644
645     tty_printf(_(
646 "We need to generate a lot of random bytes. It is a good idea to perform\n"
647 "some other action (work in another window, move the mouse, utilize the\n"
648 "network and the disks) during the prime generation; this gives the random\n"
649 "number generator a better chance to gain enough entropy.\n") );
650
651     if( algo == PUBKEY_ALGO_ELGAMAL )
652         rc = gen_elg(nbits, pub_root, sec_root, dek, s2k,  &skc, valid_days );
653   #ifdef ENABLE_RSA_KEYGEN
654     else if( algo == PUBKEY_ALGO_RSA )
655         rc = gen_rsa(nbits, pub_root, sec_root, dek, s2k, &skc, valid_days  );
656   #endif
657     else if( algo == PUBKEY_ALGO_DSA )
658         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, &skc, valid_days);
659     else
660         BUG();
661     if( !rc ) {
662         add_kbnode( pub_root,
663                 make_comment_node("#created by GNUPG v" VERSION " ("
664                                             PRINTABLE_OS_NAME ")"));
665         add_kbnode( sec_root,
666                 make_comment_node("#created by GNUPG v" VERSION " ("
667                                             PRINTABLE_OS_NAME ")"));
668     }
669     if( !rc )
670         write_uid(pub_root, uid );
671     if( !rc )
672         write_uid(sec_root, uid );
673     if( !rc )
674         rc = write_selfsig(pub_root, pub_root, skc);
675     if( !rc )
676         rc = write_selfsig(sec_root, pub_root, skc);
677
678     if( !rc ) {
679         KBPOS pub_kbpos;
680         KBPOS sec_kbpos;
681         int rc1 = -1;
682         int rc2 = -1;
683
684         /* we can now write the certificates */
685
686         if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
687             if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
688                 log_error("can add keyblock file '%s'\n", pub_fname );
689                 rc = G10ERR_CREATE_FILE;
690             }
691             else if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
692                 log_error("can get keyblock handle for '%s'\n", pub_fname );
693                 rc = G10ERR_CREATE_FILE;
694             }
695         }
696         if( rc )
697             ;
698         else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
699             if( add_keyblock_resource( sec_fname, 1, 1 ) ) {
700                 log_error("can add keyblock file '%s'\n", sec_fname );
701                 rc = G10ERR_CREATE_FILE;
702             }
703             else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
704                 log_error("can get keyblock handle for '%s'\n", sec_fname );
705                 rc = G10ERR_CREATE_FILE;
706             }
707         }
708
709         if( rc )
710             ;
711         else if( (rc=rc1=lock_keyblock( &pub_kbpos )) )
712             log_error("can't lock public keyring: %s\n", g10_errstr(rc) );
713         else if( (rc=rc2=lock_keyblock( &sec_kbpos )) )
714             log_error("can't lock secret keyring: %s\n", g10_errstr(rc) );
715         else if( (rc=insert_keyblock( &pub_kbpos, pub_root )) )
716             log_error("can't write public key: %s\n", g10_errstr(rc) );
717         else if( (rc=insert_keyblock( &sec_kbpos, sec_root )) )
718             log_error("can't write secret key: %s\n", g10_errstr(rc) );
719         else {
720             tty_printf(_("public and secret key created and signed.\n") );
721         }
722
723         if( !rc1 )
724             unlock_keyblock( &pub_kbpos );
725         if( !rc2 )
726             unlock_keyblock( &sec_kbpos );
727     }
728
729
730     if( rc )
731         tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
732     release_kbnode( pub_root );
733     release_kbnode( sec_root );
734     if( skc ) /* the unprotected  secret certificate */
735         free_secret_cert(skc);
736     m_free(uid);
737     m_free(dek);
738     m_free(s2k);
739     m_free(pub_fname);
740     m_free(sec_fname);
741 }
742
743
744 /****************
745  * add a new subkey to an existing key.
746  */
747 void
748 generate_subkeypair( const char *userid )
749 {
750     log_fatal("To be implemented :-)\n");
751 }
752