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