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