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