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