d66585295ed57e8c47c9dffbe7a763214bf09f6c
[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) DSA (sign only)\n"), 2 );
392     if( addmode )
393         tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
394     tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 4 );
395   #if 0
396     tty_printf(    _("   (%d) ElGamal in a v3 packet\n"), 5 );
397   #endif
398
399     *ret_v4 = 1;
400     for(;;) {
401         answer = cpr_get("keygen.algo",_("Your selection? "));
402         cpr_kill_prompt();
403         algo = *answer? atoi(answer): 1;
404         m_free(answer);
405         if( algo == 1 && !addmode ) {
406             algo = 0;   /* create both keys */
407             break;
408         }
409         else if( algo == 4 ) {
410             if( cpr_get_answer_is_yes("keygen.algo.elg_se",_(
411                 "Do you really want to create a sign and encrypt key? "))) {
412                 algo = PUBKEY_ALGO_ELGAMAL;
413                 break;
414             }
415         }
416         else if( algo == 3 && addmode ) {
417             algo = PUBKEY_ALGO_ELGAMAL_E;
418             break;
419         }
420         else if( algo == 2 ) {
421             algo = PUBKEY_ALGO_DSA;
422             break;
423         }
424       #if 0
425         else if( algo == 5 ) {
426             algo = PUBKEY_ALGO_ELGAMAL_E;
427             *ret_v4 = 0;
428             break;
429         }
430       #endif
431         else
432             tty_printf(_("Invalid selection.\n"));
433     }
434     return algo;
435 }
436
437
438 static unsigned
439 ask_keysize( int algo )
440 {
441     char *answer;
442     unsigned nbits;
443
444     tty_printf(_("About to generate a new %s keypair.\n"
445                  "              minimum keysize is  768 bits\n"
446                  "              default keysize is 1024 bits\n"
447                  "    highest suggested keysize is 2048 bits\n"),
448                                         pubkey_algo_to_string(algo) );
449     for(;;) {
450         answer = cpr_get("keygen.size",
451                           _("What keysize do you want? (1024) "));
452         cpr_kill_prompt();
453         nbits = *answer? atoi(answer): 1024;
454         m_free(answer);
455         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
456             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
457         else if( nbits < 768 )
458             tty_printf(_("keysize too small; 768 is smallest value allowed.\n"));
459         else if( nbits > 2048 && !cpr_enabled() ) {
460             tty_printf(
461                 _("Keysizes larger than 2048 are not suggested because\n"
462                   "computations take REALLY long!\n"));
463             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
464                         "Are you sure that you want this keysize? ")) ) {
465                 tty_printf(_("Okay, but keep in mind that your monitor "
466                              "and keyboard radiation is also very vulnerable "
467                              "to attacks!\n"));
468                 break;
469             }
470         }
471         else if( nbits > 1536 && !cpr_enabled() ) {
472             if( cpr_get_answer_is_yes("keygen.size.large.okay",_(
473                     "Do you really need such a large keysize? ")) )
474                 break;
475         }
476         else
477             break;
478     }
479     tty_printf(_("Requested keysize is %u bits\n"), nbits );
480     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
481         nbits = ((nbits + 63) / 64) * 64;
482         tty_printf(_("rounded up to %u bits\n"), nbits );
483     }
484     else if( (nbits % 32) ) {
485         nbits = ((nbits + 31) / 32) * 32;
486         tty_printf(_("rounded up to %u bits\n"), nbits );
487     }
488     return nbits;
489 }
490
491
492 static u32
493 ask_expire_interval()
494 {
495     char *answer;
496     int valid_days=0;
497     u32 interval = 0;
498
499     tty_printf(_("Please specify how long the key should be valid.\n"
500                  "         0 = key does not expire\n"
501                  "      <n>  = key expires in n days\n"
502                  "      <n>w = key expires in n weeks\n"
503                  "      <n>m = key expires in n months\n"
504                  "      <n>y = key expires in n years\n"));
505     /* Note: The elgamal subkey for DSA has no expiration date because
506      * it must be signed with the DSA key and this one has the expiration
507      * date */
508
509     answer = NULL;
510     for(;;) {
511         int mult;
512
513         m_free(answer);
514         answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
515         cpr_kill_prompt();
516         trim_spaces(answer);
517         if( !*answer )
518             valid_days = 0;
519         else if( (mult=check_valid_days(answer)) ) {
520             valid_days = atoi(answer) * mult;
521             if( valid_days < 0 || valid_days > 32767 )
522                 valid_days = 0;
523         }
524         else {
525             tty_printf(_("invalid value\n"));
526             continue;
527         }
528
529         if( !valid_days ) {
530             tty_printf(_("Key does not expire at all\n"));
531             interval = 0;
532         }
533         else {
534             interval = valid_days * 86400L;
535             /* print the date when the key expires */
536             tty_printf(_("Key expires at %s\n"),
537                         asctimestamp(make_timestamp() + interval ) );
538         }
539
540         if( !cpr_enabled()
541              && cpr_get_answer_is_yes("keygen.valid.okay",
542                                        _("Is this correct (y/n)? ")) )
543             break;
544     }
545     m_free(answer);
546     return interval;
547 }
548
549 u32
550 ask_expiredate()
551 {
552     u32 x = ask_expire_interval();
553     return x? make_timestamp() + x : 0;
554 }
555
556 static int
557 has_invalid_email_chars( const char *s )
558 {
559     int at_seen=0;
560
561     for( ; *s; s++ ) {
562         if( *s & 0x80 )
563             return 1;
564         if( *s == '@' )
565             at_seen=1;
566         else if( !at_seen
567                  && !strchr("01234567890abcdefghijklmnopqrstuvwxyz_-.+", *s ))
568             return 1;
569         else if( at_seen
570                  && !strchr("01234567890abcdefghijklmnopqrstuvwxyz_-.", *s ) )
571             return 1;
572     }
573     return 0;
574 }
575
576
577 static char *
578 ask_user_id( int mode )
579 {
580     char *answer;
581     char *aname, *acomment, *amail, *uid;
582
583     if( !mode )
584         tty_printf( _("\n"
585 "You need a User-ID to identify your key; the software constructs the user id\n"
586 "from Real Name, Comment and Email Address in this form:\n"
587 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
588     uid = aname = acomment = amail = NULL;
589     for(;;) {
590         char *p;
591
592         if( !aname ) {
593             for(;;) {
594                 m_free(aname);
595                 aname = cpr_get("keygen.name",_("Real name: "));
596                 trim_spaces(aname);
597                 cpr_kill_prompt();
598                 if( strpbrk( aname, "<([])>" ) )
599                     tty_printf(_("Invalid character in name\n"));
600                 else if( isdigit(*aname) )
601                     tty_printf(_("Name may not start with a digit\n"));
602                 else if( strlen(aname) < 5 )
603                     tty_printf(_("Name must be at least 5 characters long\n"));
604                 else
605                     break;
606             }
607         }
608         if( !amail ) {
609             for(;;) {
610                 m_free(amail);
611                 amail = cpr_get("keygen.email",_("Email address: "));
612                 trim_spaces(amail);
613                 strlwr(amail);
614                 cpr_kill_prompt();
615                 if( !*amail )
616                     break;   /* no email address is okay */
617                 else if( has_invalid_email_chars(amail)
618                          || string_count_chr(amail,'@') != 1
619                          || *amail == '@'
620                          || amail[strlen(amail)-1] == '@'
621                          || amail[strlen(amail)-1] == '.'
622                          || strstr(amail, "..") )
623                     tty_printf(_("Not a valid email address\n"));
624                 else
625                     break;
626             }
627         }
628         if( !acomment ) {
629             for(;;) {
630                 m_free(acomment);
631                 acomment = cpr_get("keygen.comment",_("Comment: "));
632                 trim_spaces(acomment);
633                 cpr_kill_prompt();
634                 if( !*acomment )
635                     break;   /* no comment is okay */
636                 else if( strpbrk( acomment, "()" ) )
637                     tty_printf(_("Invalid character in comment\n"));
638                 else
639                     break;
640             }
641         }
642
643         m_free(uid);
644         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
645         p = stpcpy(p, aname );
646         if( *acomment )
647             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
648         if( *amail )
649             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
650
651         /* append a warning if we do not have dev/random
652          * or it is switched into  quick testmode */
653         if( quick_random_gen(-1) )
654             strcpy(p, " (INSECURE!)" );
655
656
657         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
658         /* fixme: add a warning if this user-id already exists */
659         for(;;) {
660             char *ansstr = _("NnCcEeOoQq");
661
662             if( strlen(ansstr) != 10 )
663                 BUG();
664             if( cpr_enabled() ) {
665                 answer = m_strdup(ansstr+6);
666                 answer[1] = 0;
667             }
668             else {
669                 answer = cpr_get("keygen.userid.cmd",_(
670                     "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
671                 cpr_kill_prompt();
672             }
673             if( strlen(answer) > 1 )
674                 ;
675             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
676                 m_free(aname); aname = NULL;
677                 break;
678             }
679             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
680                 m_free(acomment); acomment = NULL;
681                 break;
682             }
683             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
684                 m_free(amail); amail = NULL;
685                 break;
686             }
687             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
688                 m_free(aname); aname = NULL;
689                 m_free(acomment); acomment = NULL;
690                 m_free(amail); amail = NULL;
691                 break;
692             }
693             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
694                 m_free(aname); aname = NULL;
695                 m_free(acomment); acomment = NULL;
696                 m_free(amail); amail = NULL;
697                 m_free(uid); uid = NULL;
698                 break;
699             }
700             m_free(answer);
701         }
702         m_free(answer);
703         if( !amail && !acomment && !amail )
704             break;
705         m_free(uid); uid = NULL;
706     }
707     if( uid ) {
708         char *p = native_to_utf8( uid );
709         m_free( uid );
710         uid = p;
711     }
712     return uid;
713 }
714
715
716 static DEK *
717 ask_passphrase( STRING2KEY **ret_s2k )
718 {
719     DEK *dek = NULL;
720     STRING2KEY *s2k;
721
722     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
723
724     s2k = m_alloc_secure( sizeof *s2k );
725     for(;;) {
726         s2k->mode = opt.s2k_mode;
727         s2k->hash_algo = opt.s2k_digest_algo;
728         dek = passphrase_to_dek( NULL, opt.s2k_cipher_algo, s2k, 2 );
729         if( !dek ) {
730             tty_printf(_("passphrase not correctly repeated; try again.\n"));
731         }
732         else if( !dek->keylen ) {
733             m_free(dek); dek = NULL;
734             m_free(s2k); s2k = NULL;
735             tty_printf(_(
736             "You don't want a passphrase - this is probably a *bad* idea!\n"
737             "I will do it anyway.  You can change your passphrase at any time,\n"
738             "using this program with the option \"--edit-key\".\n\n"));
739             break;
740         }
741         else
742             break; /* okay */
743     }
744     *ret_s2k = s2k;
745     return dek;
746 }
747
748
749 static int
750 do_create( int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root,
751            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
752                                                              int v4_packet )
753 {
754     int rc=0;
755
756     tty_printf(_(
757 "We need to generate a lot of random bytes. It is a good idea to perform\n"
758 "some other action (work in another window, move the mouse, utilize the\n"
759 "network and the disks) during the prime generation; this gives the random\n"
760 "number generator a better chance to gain enough entropy.\n") );
761
762     if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
763         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k,
764                            sk, expiredate, v4_packet? 4:3 );
765     else if( algo == PUBKEY_ALGO_DSA )
766         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
767     else
768         BUG();
769
770   #ifdef ENABLE_COMMENT_PACKETS
771     if( !rc ) {
772         add_kbnode( pub_root,
773                 make_comment_node("#created by GNUPG v" VERSION " ("
774                                             PRINTABLE_OS_NAME ")"));
775         add_kbnode( sec_root,
776                 make_comment_node("#created by GNUPG v" VERSION " ("
777                                             PRINTABLE_OS_NAME ")"));
778     }
779   #endif
780     return rc;
781 }
782
783
784 /****************
785  * Generate a new user id packet, or return NULL if cancelled
786  */
787 PKT_user_id *
788 generate_user_id()
789 {
790     PKT_user_id *uid;
791     char *p;
792     size_t n;
793
794     p = ask_user_id( 1 );
795     if( !p )
796         return NULL;
797     n = strlen(p);
798     uid = m_alloc( sizeof *uid + n - 1 );
799     uid->len = n;
800     strcpy(uid->name, p);
801     return uid;
802 }
803
804
805 /****************
806  * Generate a keypair
807  */
808 void
809 generate_keypair()
810 {
811     unsigned nbits;
812     char *pub_fname = NULL;
813     char *sec_fname = NULL;
814     char *uid = NULL;
815     KBNODE pub_root = NULL;
816     KBNODE sec_root = NULL;
817     PKT_secret_key *sk = NULL;
818     DEK *dek;
819     STRING2KEY *s2k;
820     int rc;
821     int algo;
822     u32 expire;
823     int v4;
824     int both = 0;
825
826     if( opt.batch || opt.answer_yes || opt.answer_no ) {
827         log_error(_("Key generation can only be used in interactive mode\n"));
828         return;
829     }
830
831     algo = ask_algo( &v4, 0 );
832     if( !algo ) {
833         algo = PUBKEY_ALGO_ELGAMAL_E;
834         both = 1;
835         tty_printf(_("DSA keypair will have 1024 bits.\n"));
836     }
837     nbits = ask_keysize( algo );
838     expire = ask_expire_interval();
839     uid = ask_user_id(0);
840     if( !uid ) {
841         log_error(_("Key generation cancelled.\n"));
842         return;
843     }
844     dek = ask_passphrase( &s2k );
845
846
847     /* now check whether we are allowed to write to the keyrings */
848     pub_fname = make_filename(opt.homedir, "pubring.gpg", NULL );
849     sec_fname = make_filename(opt.homedir, "secring.gpg", NULL );
850     if( opt.verbose ) {
851         tty_printf(_("writing public certificate to `%s'\n"), pub_fname );
852         tty_printf(_("writing secret certificate to `%s'\n"), sec_fname );
853     }
854
855     /* we create the packets as a tree of kbnodes. Because the structure
856      * we create is known in advance we simply generate a linked list
857      * The first packet is a dummy comment packet which we flag
858      * as deleted.  The very first packet must always be a KEY packet.
859      */
860     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
861     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
862
863     if( both )
864         rc = do_create( PUBKEY_ALGO_DSA, 1024, pub_root, sec_root,
865                                                dek, s2k, &sk, expire, 1);
866     else
867         rc = do_create( algo,           nbits, pub_root, sec_root,
868                                                dek, s2k, &sk, expire, v4);
869     if( !rc )
870         write_uid(pub_root, uid );
871     if( !rc )
872         write_uid(sec_root, uid );
873     if( !rc )
874         rc = write_selfsig(pub_root, pub_root, sk);
875     if( !rc )
876         rc = write_selfsig(sec_root, pub_root, sk);
877
878     if( both ) {
879         rc = do_create( algo, nbits, pub_root, sec_root,
880                                           dek, s2k, NULL, expire, 1 );
881         if( !rc )
882             rc = write_keybinding(pub_root, pub_root, sk);
883         if( !rc )
884             rc = write_keybinding(sec_root, pub_root, sk);
885     }
886
887
888     if( !rc ) {
889         KBPOS pub_kbpos;
890         KBPOS sec_kbpos;
891         int rc1 = -1;
892         int rc2 = -1;
893
894         /* we can now write the certificates */
895         if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
896             if( add_keyblock_resource( pub_fname, 1, 0 ) ) {
897                 log_error("can add keyblock file `%s'\n", pub_fname );
898                 rc = G10ERR_CREATE_FILE;
899             }
900             else if( get_keyblock_handle( pub_fname, 0, &pub_kbpos ) ) {
901                 log_error("can get keyblock handle for `%s'\n", pub_fname );
902                 rc = G10ERR_CREATE_FILE;
903             }
904         }
905         if( rc )
906             ;
907         else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
908             if( add_keyblock_resource( sec_fname, 1, 1 ) ) {
909                 log_error("can add keyblock file `%s'\n", sec_fname );
910                 rc = G10ERR_CREATE_FILE;
911             }
912             else if( get_keyblock_handle( sec_fname, 1, &sec_kbpos ) ) {
913                 log_error("can get keyblock handle for `%s'\n", sec_fname );
914                 rc = G10ERR_CREATE_FILE;
915             }
916         }
917
918         if( rc )
919             ;
920         else if( (rc=rc1=lock_keyblock( &pub_kbpos )) )
921             log_error("can't lock public keyring: %s\n", g10_errstr(rc) );
922         else if( (rc=rc2=lock_keyblock( &sec_kbpos )) )
923             log_error("can't lock secret keyring: %s\n", g10_errstr(rc) );
924         else if( (rc=insert_keyblock( &pub_kbpos, pub_root )) )
925             log_error("can't write public key: %s\n", g10_errstr(rc) );
926         else if( (rc=insert_keyblock( &sec_kbpos, sec_root )) )
927             log_error("can't write secret key: %s\n", g10_errstr(rc) );
928         else {
929             tty_printf(_("public and secret key created and signed.\n") );
930             if( algo == PUBKEY_ALGO_DSA )
931                 tty_printf(_("Note that this key cannot be used for "
932                              "encryption.  You may want to use\n"
933                              "the command \"--add-key\" to generate a "
934                              "secondary key for this purpose.\n") );
935         }
936
937         if( !rc1 )
938             unlock_keyblock( &pub_kbpos );
939         if( !rc2 )
940             unlock_keyblock( &sec_kbpos );
941     }
942
943
944     if( rc )
945         tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
946     release_kbnode( pub_root );
947     release_kbnode( sec_root );
948     if( sk ) /* the unprotected  secret key */
949         free_secret_key(sk);
950     m_free(uid);
951     m_free(dek);
952     m_free(s2k);
953     m_free(pub_fname);
954     m_free(sec_fname);
955 }
956
957
958 /****************
959  * add a new subkey to an existing key.
960  * Returns true if a new key has been generated and put into the keyblocks.
961  */
962 int
963 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
964 {
965     int okay=0, rc=0;
966     KBNODE node;
967     PKT_secret_key *sk = NULL; /* this is the primary sk */
968     int v4, algo;
969     u32 expire;
970     unsigned nbits;
971     char *passphrase = NULL;
972     DEK *dek = NULL;
973     STRING2KEY *s2k = NULL;
974
975     /* break out the primary secret key */
976     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
977     if( !node ) {
978         log_error("Oops; secret key not found anymore!\n");
979         goto leave;
980     }
981
982     /* make a copy of the sk to keep the protected one in the keyblock */
983     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
984     /* unprotect to get the passphrase */
985     switch( is_secret_key_protected( sk ) ) {
986       case -1:
987         rc = G10ERR_PUBKEY_ALGO;
988         break;
989       case 0:
990         tty_printf("This key is not protected.\n");
991         break;
992       default:
993         tty_printf("Key is protected.\n");
994         rc = check_secret_key( sk, 0 );
995         if( !rc )
996             passphrase = get_last_passphrase();
997         break;
998     }
999     if( rc )
1000         goto leave;
1001
1002
1003     algo = ask_algo( &v4, 1 );
1004     assert(algo);
1005     nbits = ask_keysize( algo );
1006     expire = ask_expire_interval();
1007     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
1008                                                   _("Really create? ") ) )
1009         goto leave;
1010
1011     if( passphrase ) {
1012         s2k = m_alloc_secure( sizeof *s2k );
1013         s2k->mode = opt.s2k_mode;
1014         s2k->hash_algo = opt.s2k_digest_algo;
1015         set_next_passphrase( passphrase );
1016         dek = passphrase_to_dek( NULL, opt.s2k_cipher_algo, s2k, 2 );
1017     }
1018
1019     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
1020                                       dek, s2k, NULL, expire, v4 );
1021     if( !rc )
1022         rc = write_keybinding(pub_keyblock, pub_keyblock, sk);
1023     if( !rc )
1024         rc = write_keybinding(sec_keyblock, pub_keyblock, sk);
1025     if( !rc )
1026         okay = 1;
1027
1028   leave:
1029     if( rc )
1030         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
1031     m_free( passphrase );
1032     m_free( dek );
1033     m_free( s2k );
1034     if( sk ) /* release the copy of the (now unprotected) secret key */
1035         free_secret_key(sk);
1036     set_next_passphrase( NULL );
1037     return okay;
1038 }
1039