bug fixes
[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 static void
39 write_uid( KBNODE root, const char *s )
40 {
41     PACKET *pkt = m_alloc_clear(sizeof *pkt );
42     size_t n = strlen(s);
43
44     pkt->pkttype = PKT_USER_ID;
45     pkt->pkt.user_id = m_alloc( sizeof *pkt->pkt.user_id + n - 1 );
46     pkt->pkt.user_id->len = n;
47     strcpy(pkt->pkt.user_id->name, s);
48     add_kbnode( root, new_kbnode( pkt ) );
49 }
50
51
52
53 static int
54 add_key_expire( PKT_signature *sig, void *opaque )
55 {
56     PKT_secret_cert *skc = opaque;
57     byte buf[8];
58     u32  u;
59
60     if( skc->valid_days ) {
61         u = skc->valid_days * 86400L;
62         buf[0] = (u >> 24) & 0xff;
63         buf[1] = (u >> 16) & 0xff;
64         buf[2] = (u >>  8) & 0xff;
65         buf[3] = u & 0xff;
66         build_sig_subpkt( sig, SIGSUBPKT_KEY_EXPIRE, buf, 4 );
67     }
68
69     return 0;
70 }
71
72
73 /****************
74  * Add preference to the self signature packet.
75  * This is only called for packets with version > 3.
76  */
77 static int
78 add_prefs( PKT_signature *sig, void *opaque )
79 {
80     byte buf[8];
81
82     add_key_expire( sig, opaque );
83
84     buf[0] = CIPHER_ALGO_BLOWFISH;
85     buf[1] = CIPHER_ALGO_CAST5;
86     build_sig_subpkt( sig, SIGSUBPKT_PREF_SYM, buf, 2 );
87
88     buf[0] = DIGEST_ALGO_RMD160;
89     buf[1] = DIGEST_ALGO_SHA1;
90     buf[2] = DIGEST_ALGO_TIGER;
91     buf[3] = DIGEST_ALGO_MD5;
92     build_sig_subpkt( sig, SIGSUBPKT_PREF_HASH, buf, 4 );
93
94     buf[0] = 2;
95     buf[1] = 1;
96     build_sig_subpkt( sig, SIGSUBPKT_PREF_COMPR, buf, 2 );
97
98     buf[0] = 0x80; /* no modify - It is reasonable that a key holder
99                     * has the possibility to reject signatures from users
100                     * who are known to sign everything without any
101                     * validation - so a signed key should be send
102                     * to the holder who in turn can put it on a keyserver
103                     */
104     build_sig_subpkt( sig, SIGSUBPKT_KS_FLAGS, buf, 1 );
105
106     return 0;
107 }
108
109
110
111 static int
112 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_cert *skc )
113 {
114     PACKET *pkt;
115     PKT_signature *sig;
116     PKT_user_id *uid;
117     int rc=0;
118     KBNODE node;
119     PKT_public_cert *pkc;
120
121     if( opt.verbose )
122         log_info(_("writing self signature\n"));
123
124     /* get the uid packet from the list */
125     node = find_kbnode( root, PKT_USER_ID );
126     if( !node )
127         BUG(); /* no user id packet in tree */
128     uid = node->pkt->pkt.user_id;
129     /* get the pkc packet from the pub_tree */
130     node = find_kbnode( pub_root, PKT_PUBLIC_CERT );
131     if( !node )
132         BUG();
133     pkc = node->pkt->pkt.public_cert;
134
135     /* and make the signature */
136     rc = make_keysig_packet( &sig, pkc, uid, NULL, skc, 0x13, 0,
137                              add_prefs, skc );
138     if( rc ) {
139         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
140         return rc;
141     }
142
143     pkt = m_alloc_clear( sizeof *pkt );
144     pkt->pkttype = PKT_SIGNATURE;
145     pkt->pkt.signature = sig;
146     add_kbnode( root, new_kbnode( pkt ) );
147     return rc;
148 }
149
150 static int
151 write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_cert *skc )
152 {
153     PACKET *pkt;
154     PKT_signature *sig;
155     int rc=0;
156     KBNODE node;
157     PKT_public_cert *pkc, *subpkc;
158
159     if( opt.verbose )
160         log_info(_("writing key binding signature\n"));
161
162     /* get the pkc packet from the pub_tree */
163     node = find_kbnode( pub_root, PKT_PUBLIC_CERT );
164     if( !node )
165         BUG();
166     pkc = node->pkt->pkt.public_cert;
167     /* find the last subkey */
168     subpkc = NULL;
169     for(node=pub_root; node; node = node->next ) {
170         if( node->pkt->pkttype == PKT_PUBKEY_SUBCERT )
171             subpkc = node->pkt->pkt.public_cert;
172     }
173     if( !subpkc )
174         BUG();
175
176     /* and make the signature */
177     rc = make_keysig_packet( &sig, pkc, NULL, subpkc, skc, 0x18, 0,
178                                     add_key_expire, skc );
179     if( rc ) {
180         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
181         return rc;
182     }
183
184     pkt = m_alloc_clear( sizeof *pkt );
185     pkt->pkttype = PKT_SIGNATURE;
186     pkt->pkt.signature = sig;
187     add_kbnode( root, new_kbnode( pkt ) );
188     return rc;
189 }
190
191
192 static int
193 gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
194         STRING2KEY *s2k, PKT_secret_cert **ret_skc, u16 valid_days,
195                                                         int version )
196 {
197     int rc;
198     int i;
199     PACKET *pkt;
200     PKT_secret_cert *skc;
201     PKT_public_cert *pkc;
202     MPI skey[4];
203     MPI *factors;
204
205     assert( is_ELGAMAL(algo) );
206     rc = pubkey_generate( algo, nbits, skey, &factors );
207     if( rc ) {
208         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
209         return rc;
210     }
211
212     skc = m_alloc_clear( sizeof *skc );
213     pkc = m_alloc_clear( sizeof *pkc );
214     skc->timestamp = pkc->timestamp = make_timestamp();
215     skc->version = pkc->version = version;
216     skc->valid_days = pkc->valid_days = valid_days;
217     skc->pubkey_algo = pkc->pubkey_algo = algo;
218                        pkc->pkey[0] = mpi_copy( skey[0] );
219                        pkc->pkey[1] = mpi_copy( skey[1] );
220                        pkc->pkey[2] = mpi_copy( skey[2] );
221     skc->skey[0] = skey[0];
222     skc->skey[1] = skey[1];
223     skc->skey[2] = skey[2];
224     skc->skey[3] = skey[3];
225     skc->is_protected = 0;
226     skc->protect.algo = 0;
227
228     skc->csum = checksum_mpi_counted_nbits( skc->skey[3] );
229     if( ret_skc ) /* not a subkey: return an unprotected version of the skc */
230         *ret_skc = copy_secret_cert( NULL, skc );
231
232     if( dek ) {
233         skc->protect.algo = dek->algo;
234         skc->protect.s2k = *s2k;
235         rc = protect_secret_key( skc, dek );
236         if( rc ) {
237             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
238             free_public_cert(pkc);
239             free_secret_cert(skc);
240             return rc;
241         }
242     }
243
244     pkt = m_alloc_clear(sizeof *pkt);
245     pkt->pkttype = ret_skc ? PKT_PUBLIC_CERT : PKT_PUBKEY_SUBCERT;
246     pkt->pkt.public_cert = pkc;
247     add_kbnode(pub_root, new_kbnode( pkt ));
248
249     /* don't know whether it makes sense to have the factors, so for now
250      * we store them in the secret keyring (but they are not secret) */
251     pkt = m_alloc_clear(sizeof *pkt);
252     pkt->pkttype = ret_skc ? PKT_SECRET_CERT : PKT_SECKEY_SUBCERT;
253     pkt->pkt.secret_cert = skc;
254     add_kbnode(sec_root, new_kbnode( pkt ));
255     for(i=0; factors[i]; i++ )
256         add_kbnode( sec_root,
257                     make_mpi_comment_node("#:ELG_factor:", factors[i] ));
258
259     return 0;
260 }
261
262
263 /****************
264  * Generate a DSA key
265  */
266 static int
267 gen_dsa(unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
268             STRING2KEY *s2k, PKT_secret_cert **ret_skc, u16 valid_days )
269 {
270     int rc;
271     int i;
272     PACKET *pkt;
273     PKT_secret_cert *skc;
274     PKT_public_cert *pkc;
275     MPI skey[5];
276     MPI *factors;
277
278     if( nbits > 1024 )
279         nbits = 1024;
280
281     rc = pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors );
282     if( rc ) {
283         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
284         return rc;
285     }
286
287     skc = m_alloc_clear( sizeof *skc );
288     pkc = m_alloc_clear( sizeof *pkc );
289     skc->timestamp = pkc->timestamp = make_timestamp();
290     skc->version = pkc->version = 4;
291     skc->valid_days = pkc->valid_days = valid_days;
292     skc->pubkey_algo = pkc->pubkey_algo = PUBKEY_ALGO_DSA;
293                        pkc->pkey[0] = mpi_copy( skey[0] );
294                        pkc->pkey[1] = mpi_copy( skey[1] );
295                        pkc->pkey[2] = mpi_copy( skey[2] );
296                        pkc->pkey[3] = mpi_copy( skey[3] );
297     skc->skey[0] = skey[0];
298     skc->skey[1] = skey[1];
299     skc->skey[2] = skey[2];
300     skc->skey[3] = skey[3];
301     skc->skey[4] = skey[4];
302     skc->is_protected = 0;
303     skc->protect.algo = 0;
304
305     skc->csum = checksum_mpi_counted_nbits( skc->skey[4] );
306     if( ret_skc ) /* not a subkey: return an unprotected version of the skc */
307         *ret_skc = copy_secret_cert( NULL, skc );
308
309     if( dek ) {
310         skc->protect.algo = dek->algo;
311         skc->protect.s2k = *s2k;
312         rc = protect_secret_key( skc, dek );
313         if( rc ) {
314             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
315             free_public_cert(pkc);
316             free_secret_cert(skc);
317             return rc;
318         }
319     }
320
321     pkt = m_alloc_clear(sizeof *pkt);
322     pkt->pkttype = ret_skc ? PKT_PUBLIC_CERT : PKT_PUBKEY_SUBCERT;
323     pkt->pkt.public_cert = pkc;
324     add_kbnode(pub_root, new_kbnode( pkt ));
325
326     /* don't know whether it makes sense to have the factors, so for now
327      * we store them in the secret keyring (but they are not secret)
328      * p = 2 * q * f1 * f2 * ... * fn
329      * We store only f1 to f_n-1;  fn can be calculated because p and q
330      * are known.
331      */
332     pkt = m_alloc_clear(sizeof *pkt);
333     pkt->pkttype = ret_skc ? PKT_SECRET_CERT : PKT_SECKEY_SUBCERT;
334     pkt->pkt.secret_cert = skc;
335     add_kbnode(sec_root, new_kbnode( pkt ));
336     for(i=1; factors[i]; i++ )  /* the first one is q */
337         add_kbnode( sec_root,
338                     make_mpi_comment_node("#:DSA_factor:", factors[i] ));
339
340     return 0;
341 }
342
343
344
345 /****************
346  * check valid days:
347  * return 0 on error or the multiplier
348  */
349 static int
350 check_valid_days( const char *s )
351 {
352     if( !isdigit(*s) )
353         return 0;
354     for( s++; *s; s++)
355         if( !isdigit(*s) )
356             break;
357     if( !*s )
358         return 1;
359     if( s[1] )
360         return 0; /* e.g. "2323wc" */
361     if( *s == 'd' || *s == 'D' )
362         return 1;
363     if( *s == 'w' || *s == 'W' )
364         return 7;
365     if( *s == 'm' || *s == 'M' )
366         return 30;
367     if( *s == 'y' || *s == 'Y' )
368         return 365;
369     return 0;
370 }
371
372
373 /****************
374  * Returns o to create both a DSA and a ElGamal key.
375  */
376 static int
377 ask_algo( int *ret_v4, int addmode )
378 {
379     char *answer;
380     int algo;
381
382     tty_printf(_("Please select what kind of key you want:\n"));
383     if( !addmode )
384         tty_printf(_("   (%d) DSA and ElGamal (default)\n"), 1 );
385     tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 2 );
386     tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
387     tty_printf(    _("   (%d) DSA (sign only)\n"), 4 );
388     tty_printf(    _("   (%d) ElGamal in a v3 packet\n"), 5 );
389
390     *ret_v4 = 1;
391     for(;;) {
392         answer = tty_get(_("Your selection? "));
393         tty_kill_prompt();
394         algo = *answer? atoi(answer): 1;
395         m_free(answer);
396         if( algo == 1 && !addmode ) {
397             algo = 0;   /* create both keys */
398             break;
399         }
400         else if( algo == 2 ) {
401             algo = PUBKEY_ALGO_ELGAMAL;
402             break;
403         }
404         else if( algo == 3 ) {
405             algo = PUBKEY_ALGO_ELGAMAL_E;
406             break;
407         }
408         else if( algo == 4 ) {
409             algo = PUBKEY_ALGO_DSA;
410             break;
411         }
412         else if( algo == 5 ) {
413             algo = PUBKEY_ALGO_ELGAMAL_E;
414             *ret_v4 = 0;
415             break;
416         }
417         else
418             tty_printf(_("Invalid selection.\n"));
419     }
420     return algo;
421 }
422
423
424 static unsigned
425 ask_keysize( int algo )
426 {
427     char *answer;
428     unsigned nbits;
429
430     tty_printf(_("About to generate a new %s keypair.\n"
431                  "              minimum keysize is  768 bits\n"
432                  "              default keysize is 1024 bits\n"
433                  "    highest suggested keysize is 2048 bits\n"),
434                                         pubkey_algo_to_string(algo) );
435     for(;;) {
436         answer = tty_get(_("What keysize do you want? (1024) "));
437         tty_kill_prompt();
438         nbits = *answer? atoi(answer): 1024;
439         m_free(answer);
440         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
441             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
442         else if( nbits < 768 )
443             tty_printf(_("keysize too small; 768 is smallest value allowed.\n"));
444         else if( nbits > 2048 ) {
445             tty_printf(_("Keysizes larger than 2048 are not suggested, because "
446                          "computations take REALLY long!\n"));
447             answer = tty_get(_("Are you sure, that you want this keysize? "));
448             tty_kill_prompt();
449             if( answer_is_yes(answer) ) {
450                 m_free(answer);
451                 tty_printf(_("Okay, but keep in mind that your monitor "
452                              "and keyboard radiation is also very vulnerable "
453                              "to attacks!\n"));
454                 break;
455             }
456             m_free(answer);
457         }
458         else if( nbits > 1536 ) {
459             answer = tty_get(_("Do you really need such a large keysize? "));
460             tty_kill_prompt();
461             if( answer_is_yes(answer) ) {
462                 m_free(answer);
463                 break;
464             }
465             m_free(answer);
466         }
467         else
468             break;
469     }
470     tty_printf(_("Requested keysize is %u bits\n"), nbits );
471     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
472         nbits = ((nbits + 63) / 64) * 64;
473         tty_printf(_("rounded up to %u bits\n"), nbits );
474     }
475     else if( (nbits % 32) ) {
476         nbits = ((nbits + 31) / 32) * 32;
477         tty_printf(_("rounded up to %u bits\n"), nbits );
478     }
479     return nbits;
480 }
481
482
483 static int
484 ask_valid_days()
485 {
486     char *answer;
487     int valid_days=0;
488
489     tty_printf(_("Please specify how long the key should be valid.\n"
490                  "         0 = key does not expire\n"
491                  "      <n>  = key expires in n days\n"
492                  "      <n>w = key expires in n weeks\n"
493                  "      <n>m = key expires in n months\n"
494                  "      <n>y = key expires in n years\n"));
495     /* Note: The elgamal subkey for DSA has no exiration date because
496      * is must be signed with the DSA key and this one has the expiration
497      * date */
498
499     answer = NULL;
500     for(;;) {
501         int mult;
502
503         m_free(answer);
504         answer = tty_get(_("Key is valid for? (0) "));
505         tty_kill_prompt();
506         trim_spaces(answer);
507         if( !*answer )
508             valid_days = 0;
509         else if( (mult=check_valid_days(answer)) ) {
510             valid_days = atoi(answer) * mult;
511             if( valid_days < 0 || valid_days > 32767 )
512                 valid_days = 0;
513         }
514         else {
515             tty_printf(_("invalid value\n"));
516             continue;
517         }
518
519         if( !valid_days )
520             tty_printf(_("Key does not expire at all\n"));
521         else {
522             /* print the date when the key expires */
523             tty_printf(_("Key expires at %s\n"), strtimestamp(
524                        add_days_to_timestamp( make_timestamp(), valid_days )));
525         }
526
527         m_free(answer);
528         answer = tty_get(_("Is this correct (y/n)? "));
529         tty_kill_prompt();
530         if( answer_is_yes(answer) )
531             break;
532     }
533     m_free(answer);
534     return valid_days;
535 }
536
537
538 static int
539 has_invalid_email_chars( const char *s )
540 {
541     for( ; *s; s++ ) {
542         if( *s & 0x80 )
543             return 1;
544         if( !strchr("01234567890abcdefghijklmnopqrstuvwxyz_-.@", *s ) )
545             return 1;
546     }
547     return 0;
548 }
549
550
551 static char *
552 ask_user_id()
553 {
554     char *answer;
555     char *aname, *acomment, *amail, *uid;
556
557     tty_printf( _("\n"
558 "You need a User-ID to identify your key; the software constructs the user id\n"
559 "from Real Name, Comment and Email Address in this form:\n"
560 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
561     uid = aname = acomment = amail = NULL;
562     for(;;) {
563         char *p;
564
565         if( !aname ) {
566             for(;;) {
567                 m_free(aname);
568                 aname = tty_get(_("Real name: "));
569                 trim_spaces(aname);
570                 tty_kill_prompt();
571                 if( strpbrk( aname, "<([])>" ) )
572                     tty_printf(_("Invalid character in name\n"));
573                 else if( isdigit(*aname) )
574                     tty_printf(_("Name may not start with a digit\n"));
575                 else if( strlen(aname) < 5 )
576                     tty_printf(_("Name must be at least 5 characters long\n"));
577                 else
578                     break;
579             }
580         }
581         if( !amail ) {
582             for(;;) {
583                 m_free(amail);
584                 amail = tty_get(_("Email address: "));
585                 trim_spaces(amail);
586                 strlwr(amail);
587                 tty_kill_prompt();
588                 if( !*amail )
589                     break;   /* no email address is okay */
590                 else if( has_invalid_email_chars(amail)
591                          || string_count_chr(amail,'@') != 1
592                          || *amail == '@'
593                          || amail[strlen(amail)-1] == '@'
594                          || amail[strlen(amail)-1] == '.'
595                          || strstr(amail, "..") )
596                     tty_printf(_("Not a valid email address\n"));
597                 else
598                     break;
599             }
600         }
601         if( !acomment ) {
602             for(;;) {
603                 m_free(acomment);
604                 acomment = tty_get(_("Comment: "));
605                 trim_spaces(acomment);
606                 tty_kill_prompt();
607                 if( !*acomment )
608                     break;   /* no comment is okay */
609                 else if( strpbrk( acomment, "()" ) )
610                     tty_printf(_("Invalid character in comment\n"));
611                 else
612                     break;
613             }
614         }
615
616         m_free(uid);
617         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
618         p = stpcpy(p, aname );
619         if( *acomment )
620             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
621         if( *amail )
622             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
623
624         /* append a warning if we do not have dev/random
625          * or it is switched into  quick testmode */
626         if( quick_random_gen(-1) )
627             strcpy(p, " (INSECURE!)" );
628
629
630         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
631         /* fixme: add a warning if this user-id already exists */
632         for(;;) {
633             answer = tty_get(_("Edit (N)ame, (C)omment, (E)mail or (O)kay? "));
634             tty_kill_prompt();
635             if( strlen(answer) > 1 )
636                 ;
637             else if( *answer == 'N' || *answer == 'n' ) {
638                 m_free(aname); aname = NULL;
639                 break;
640             }
641             else if( *answer == 'C' || *answer == 'c' ) {
642                 m_free(acomment); acomment = NULL;
643                 break;
644             }
645             else if( *answer == 'E' || *answer == 'e' ) {
646                 m_free(amail); amail = NULL;
647                 break;
648             }
649             else if( *answer == 'O' || *answer == 'o' ) {
650                 m_free(aname); aname = NULL;
651                 m_free(acomment); acomment = NULL;
652                 m_free(amail); amail = NULL;
653                 break;
654             }
655             m_free(answer);
656         }
657         m_free(answer);
658         if( !amail && !acomment && !amail )
659             break;
660         m_free(uid); uid = NULL;
661     }
662     return uid;
663 }
664
665
666 static DEK *
667 ask_passphrase( STRING2KEY **ret_s2k )
668 {
669     DEK *dek = NULL;
670     STRING2KEY *s2k;
671
672     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
673
674     s2k = m_alloc_secure( sizeof *s2k );
675     for(;;) {
676         s2k->mode = 1;
677         s2k->hash_algo = DIGEST_ALGO_RMD160;
678         dek = passphrase_to_dek( NULL, CIPHER_ALGO_BLOWFISH, s2k, 2 );
679         if( !dek ) {
680             tty_printf(_("passphrase not correctly repeated; try again.\n"));
681         }
682         else if( !dek->keylen ) {
683             m_free(dek); dek = NULL;
684             m_free(s2k); s2k = NULL;
685             tty_printf(_(
686             "You don't want a passphrase - this is probably a *bad* idea!\n"
687             "I will do it anyway.  You can change your passphrase at any time,\n"
688             "using this program with the option \"--change-passphrase\"\n\n"));
689             break;
690         }
691         else
692             break; /* okay */
693     }
694     *ret_s2k = s2k;
695     return dek;
696 }
697
698
699 static int
700 do_create( int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root,
701            DEK *dek, STRING2KEY *s2k, PKT_secret_cert **skc, int valid_days,
702                                                              int v4_packet )
703 {
704     int rc=0;
705
706     tty_printf(_(
707 "We need to generate a lot of random bytes. It is a good idea to perform\n"
708 "some other action (work in another window, move the mouse, utilize the\n"
709 "network and the disks) during the prime generation; this gives the random\n"
710 "number generator a better chance to gain enough entropy.\n") );
711
712     if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
713         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k,
714                            skc, valid_days, v4_packet? 4:3 );
715     else if( algo == PUBKEY_ALGO_DSA )
716         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, skc, valid_days);
717     else
718         BUG();
719     if( !rc ) {
720         add_kbnode( pub_root,
721                 make_comment_node("#created by GNUPG v" VERSION " ("
722                                             PRINTABLE_OS_NAME ")"));
723         add_kbnode( sec_root,
724                 make_comment_node("#created by GNUPG v" VERSION " ("
725                                             PRINTABLE_OS_NAME ")"));
726     }
727     return rc;
728 }
729
730
731 /****************
732  * Generate a keypair
733  */
734 void
735 generate_keypair()
736 {
737     unsigned nbits;
738     char *pub_fname = NULL;
739     char *sec_fname = NULL;
740     char *uid = NULL;
741     KBNODE pub_root = NULL;
742     KBNODE sec_root = NULL;
743     PKT_secret_cert *skc = NULL;
744     DEK *dek;
745     STRING2KEY *s2k;
746     int rc;
747     int algo;
748     int ndays;
749     int v4;
750     int both = 0;
751
752     if( opt.batch || opt.answer_yes || opt.answer_no ) {
753         log_error(_("Key generation can only be used in interactive mode\n"));
754         return;
755     }
756
757     algo = ask_algo( &v4, 0 );
758     if( !algo ) {
759         algo = PUBKEY_ALGO_ELGAMAL;
760         both = 1;
761         tty_printf(_("DSA keypair will have 1024 bits.\n"));
762     }
763     nbits = ask_keysize( algo );
764     ndays = ask_valid_days();
765     uid = ask_user_id();
766     dek = ask_passphrase( &s2k );
767
768
769     /* now check whether we are allowed to write to the keyrings */
770     pub_fname = make_filename(opt.homedir, "pubring.gpg", NULL );
771     sec_fname = make_filename(opt.homedir, "secring.gpg", NULL );
772     if( opt.verbose ) {
773         tty_printf(_("writing public certificate to '%s'\n"), pub_fname );
774         tty_printf(_("writing secret certificate to '%s'\n"), sec_fname );
775     }
776
777     /* we create the packets as a tree of kbnodes. Because the structure
778      * we create is known in advance we simply generate a linked list
779      * The first packet is a dummy comment packet which we flag
780      * as deleted.  The very first packet must always be a CERT packet.
781      */
782     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
783     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
784
785     if( both )
786         rc = do_create( PUBKEY_ALGO_DSA, 1024, pub_root, sec_root,
787                                                dek, s2k, &skc, ndays, 1);
788     else
789         rc = do_create( algo,           nbits, pub_root, sec_root,
790                                                dek, s2k, &skc, ndays, v4);
791     if( !rc )
792         write_uid(pub_root, uid );
793     if( !rc )
794         write_uid(sec_root, uid );
795     if( !rc )
796         rc = write_selfsig(pub_root, pub_root, skc);
797     if( !rc )
798         rc = write_selfsig(sec_root, pub_root, skc);
799
800     if( both ) {
801         rc = do_create( algo, nbits, pub_root, sec_root,
802                                           dek, s2k, NULL, ndays, 1 );
803         if( !rc )
804             rc = write_keybinding(pub_root, pub_root, skc);
805         if( !rc )
806             rc = write_keybinding(sec_root, pub_root, skc);
807     }
808
809
810     if( !rc ) {
811         KBPOS pub_kbpos;
812         KBPOS sec_kbpos;
813         int rc1 = -1;
814         int rc2 = -1;
815
816         /* we can now write the certificates */
817
818         if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
819             if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
820                 log_error("can add keyblock file '%s'\n", pub_fname );
821                 rc = G10ERR_CREATE_FILE;
822             }
823             else if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
824                 log_error("can get keyblock handle for '%s'\n", pub_fname );
825                 rc = G10ERR_CREATE_FILE;
826             }
827         }
828         if( rc )
829             ;
830         else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
831             if( add_keyblock_resource( sec_fname, 1, 1 ) ) {
832                 log_error("can add keyblock file '%s'\n", sec_fname );
833                 rc = G10ERR_CREATE_FILE;
834             }
835             else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
836                 log_error("can get keyblock handle for '%s'\n", sec_fname );
837                 rc = G10ERR_CREATE_FILE;
838             }
839         }
840
841         if( rc )
842             ;
843         else if( (rc=rc1=lock_keyblock( &pub_kbpos )) )
844             log_error("can't lock public keyring: %s\n", g10_errstr(rc) );
845         else if( (rc=rc2=lock_keyblock( &sec_kbpos )) )
846             log_error("can't lock secret keyring: %s\n", g10_errstr(rc) );
847         else if( (rc=insert_keyblock( &pub_kbpos, pub_root )) )
848             log_error("can't write public key: %s\n", g10_errstr(rc) );
849         else if( (rc=insert_keyblock( &sec_kbpos, sec_root )) )
850             log_error("can't write secret key: %s\n", g10_errstr(rc) );
851         else {
852             tty_printf(_("public and secret key created and signed.\n") );
853             if( algo == PUBKEY_ALGO_DSA )
854                 tty_printf(_("Note that this key cannot be used for "
855                              "encryption.  You may want to use\n"
856                              "the command \"--add-key\" to generate a "
857                              "secondary key for this purpose.\n") );
858         }
859
860         if( !rc1 )
861             unlock_keyblock( &pub_kbpos );
862         if( !rc2 )
863             unlock_keyblock( &sec_kbpos );
864     }
865
866
867     if( rc )
868         tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
869     release_kbnode( pub_root );
870     release_kbnode( sec_root );
871     if( skc ) /* the unprotected  secret certificate */
872         free_secret_cert(skc);
873     m_free(uid);
874     m_free(dek);
875     m_free(s2k);
876     m_free(pub_fname);
877     m_free(sec_fname);
878 }
879
880
881 /****************
882  * add a new subkey to an existing key.
883  */
884 void
885 generate_subkeypair( const char *username )
886 {
887     int rc=0;
888     KBPOS pub_kbpos, sec_kbpos;
889     KBNODE pub_keyblock = NULL;
890     KBNODE sec_keyblock = NULL;
891     KBNODE node;
892     PKT_secret_cert *skc = NULL; /* this is the primary skc */
893     u32 keyid[2];
894     int v4, algo, ndays;
895     unsigned nbits;
896     char *passphrase = NULL;
897     DEK *dek = NULL;
898     STRING2KEY *s2k = NULL;
899
900     if( opt.batch || opt.answer_yes || opt.answer_no ) {
901         log_error(_("Key generation can only be used in interactive mode\n"));
902         return;
903     }
904
905     /* search the userid */
906     rc = find_secret_keyblock_byname( &sec_kbpos, username );
907     if( rc ) {
908         log_error("user '%s' not found\n", username );
909         goto leave;
910     }
911     rc = read_keyblock( &sec_kbpos, &sec_keyblock );
912     if( rc ) {
913         log_error("error reading the secret key: %s\n", g10_errstr(rc) );
914         goto leave;
915     }
916     /* and the public key */
917     rc = find_keyblock_byname( &pub_kbpos, username );
918     if( rc ) {
919         log_error("user '%s' not found in public ring\n", username );
920         goto leave;
921     }
922     rc = read_keyblock( &pub_kbpos, &pub_keyblock );
923     if( rc ) {
924         log_error("error reading the public key: %s\n", g10_errstr(rc) );
925         goto leave;
926     }
927
928     /* break out the primary key */
929     node = find_kbnode( sec_keyblock, PKT_SECRET_CERT );
930     if( !node ) {
931         log_error("Oops; secret key not found anymore!\n");
932         rc = G10ERR_GENERAL;
933         goto leave;
934     }
935
936     /* make a copy of the skc to keep the protected one in the keyblock */
937     skc = copy_secret_cert( NULL, node->pkt->pkt.secret_cert );
938     keyid_from_skc( skc, keyid );
939     /* display primary and all secondary keys */
940     tty_printf("sec  %4u%c/%08lX %s   ",
941               nbits_from_skc( skc ),
942               pubkey_letter( skc->pubkey_algo ),
943               keyid[1], datestr_from_skc(skc) );
944     {
945         size_t n;
946         char *p = get_user_id( keyid, &n );
947         tty_print_string( p, n );
948         m_free(p);
949         tty_printf("\n");
950     }
951     for(node=sec_keyblock; node; node = node->next ) {
952         if( node->pkt->pkttype == PKT_SECKEY_SUBCERT ) {
953             PKT_secret_cert *subskc = node->pkt->pkt.secret_cert;
954             keyid_from_skc( subskc, keyid );
955             tty_printf("sub  %4u%c/%08lX %s\n",
956                       nbits_from_skc( subskc ),
957                       pubkey_letter( subskc->pubkey_algo ),
958                       keyid[1], datestr_from_skc(subskc) );
959         }
960     }
961     tty_printf("\n");
962
963
964
965     /* unprotect to get the passphrase */
966     switch( is_secret_key_protected( skc ) ) {
967       case -1:
968         rc = G10ERR_PUBKEY_ALGO;
969         break;
970       case 0:
971         tty_printf("This key is not protected.\n");
972         break;
973       default:
974         tty_printf("Key is protected.\n");
975         rc = check_secret_key( skc );
976         if( !rc )
977             passphrase = get_last_passphrase();
978         break;
979     }
980     if( rc )
981         goto leave;
982
983
984     algo = ask_algo( &v4, 1 );
985     assert(algo);
986     nbits = ask_keysize( algo );
987     ndays = ask_valid_days();
988
989     if( passphrase ) {
990         s2k = m_alloc_secure( sizeof *s2k );
991         s2k->mode = 1;
992         s2k->hash_algo = DIGEST_ALGO_RMD160;
993         set_next_passphrase( passphrase );
994         dek = passphrase_to_dek( NULL, CIPHER_ALGO_BLOWFISH, s2k, 2 );
995     }
996
997     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
998                                       dek, s2k, NULL, ndays, v4 );
999     if( !rc )
1000         rc = write_keybinding(pub_keyblock, pub_keyblock, skc);
1001     if( !rc )
1002         rc = write_keybinding(sec_keyblock, pub_keyblock, skc);
1003     /* write back */
1004     if( !rc ) {
1005         rc = update_keyblock( &pub_kbpos, pub_keyblock );
1006         if( rc )
1007             log_error("update_public_keyblock failed\n" );
1008     }
1009     if( !rc ) {
1010         rc = update_keyblock( &sec_kbpos, sec_keyblock );
1011         if( rc )
1012             log_error("update_secret_keyblock failed\n" );
1013     }
1014     if( !rc )
1015         tty_printf(_("public and secret subkey created.\n") );
1016
1017
1018   leave:
1019     if( rc )
1020         tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
1021     m_free( passphrase );
1022     m_free( dek );
1023     m_free( s2k );
1024     if( skc ) /* release the copy of the (now unprotected) secret key */
1025         free_secret_cert(skc);
1026     release_kbnode( sec_keyblock );
1027     release_kbnode( pub_keyblock );
1028     set_next_passphrase( NULL );
1029 }
1030