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