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