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