nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-10 09:58:01 +00:00
Code Issues Projects Releases Wiki Activity

Diffie-Hellman key exchange now uses a dynamically allocated context.

Browse Source 
[originally from svn r2135]
This commit is contained in:
Simon Tatham 2002-10-25 13:08:01 +00:00
parent 2317fe7e53
commit db7196c174
4 changed files with 63 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
ssh.c
View File

@ -569,6 +569,7 @@ struct ssh_tag {
const struct ssh_kex *kex; const struct ssh_kex *kex;
const struct ssh_signkey *hostkey; const struct ssh_signkey *hostkey;
unsigned char v2_session_id[20]; unsigned char v2_session_id[20];
void *kex_ctx;
char *savedhost; char *savedhost;
int savedport; int savedport;
@ -3953,12 +3954,12 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
} }
s->p = ssh2_pkt_getmp(ssh); s->p = ssh2_pkt_getmp(ssh);
s->g = ssh2_pkt_getmp(ssh); s->g = ssh2_pkt_getmp(ssh);
dh_setup_group(s->p, s->g); ssh->kex_ctx = dh_setup_group(s->p, s->g);
s->kex_init_value = SSH2_MSG_KEX_DH_GEX_INIT; s->kex_init_value = SSH2_MSG_KEX_DH_GEX_INIT;
s->kex_reply_value = SSH2_MSG_KEX_DH_GEX_REPLY; s->kex_reply_value = SSH2_MSG_KEX_DH_GEX_REPLY;
} else { } else {
ssh->pkt_ctx |= SSH2_PKTCTX_DHGROUP1; ssh->pkt_ctx |= SSH2_PKTCTX_DHGROUP1;
dh_setup_group1(); ssh->kex_ctx = dh_setup_group1();
s->kex_init_value = SSH2_MSG_KEXDH_INIT; s->kex_init_value = SSH2_MSG_KEXDH_INIT;
s->kex_reply_value = SSH2_MSG_KEXDH_REPLY; s->kex_reply_value = SSH2_MSG_KEXDH_REPLY;
} }
@ -3967,7 +3968,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
/* /*
* Now generate and send e for Diffie-Hellman. * Now generate and send e for Diffie-Hellman.
*/ */
s->e = dh_create_e(s->nbits * 2); s->e = dh_create_e(ssh->kex_ctx, s->nbits * 2);
ssh2_pkt_init(ssh, s->kex_init_value); ssh2_pkt_init(ssh, s->kex_init_value);
ssh2_pkt_addmp(ssh, s->e); ssh2_pkt_addmp(ssh, s->e);
ssh2_pkt_send(ssh); ssh2_pkt_send(ssh);
@ -3981,7 +3982,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
s->f = ssh2_pkt_getmp(ssh); s->f = ssh2_pkt_getmp(ssh);
ssh2_pkt_getstring(ssh, &s->sigdata, &s->siglen); ssh2_pkt_getstring(ssh, &s->sigdata, &s->siglen);
s->K = dh_find_K(s->f); s->K = dh_find_K(ssh->kex_ctx, s->f);
sha_string(&ssh->exhash, s->hostkeydata, s->hostkeylen); sha_string(&ssh->exhash, s->hostkeydata, s->hostkeylen);
if (ssh->kex == &ssh_diffiehellman_gex) { if (ssh->kex == &ssh_diffiehellman_gex) {
@ -3994,7 +3995,7 @@ static int do_ssh2_transport(Ssh ssh, unsigned char *in, int inlen, int ispkt)
sha_mpint(&ssh->exhash, s->K); sha_mpint(&ssh->exhash, s->K);
SHA_Final(&ssh->exhash, s->exchange_hash); SHA_Final(&ssh->exhash, s->exchange_hash);
dh_cleanup(); dh_cleanup(ssh->kex_ctx);
#if 0 #if 0
debug(("Exchange hash is:\n")); debug(("Exchange hash is:\n"));

14
ssh.h
View File

@ -261,8 +261,8 @@ Bignum modpow(Bignum base, Bignum exp, Bignum mod);
Bignum modmul(Bignum a, Bignum b, Bignum mod); Bignum modmul(Bignum a, Bignum b, Bignum mod);
void decbn(Bignum n); void decbn(Bignum n);
extern Bignum Zero, One; extern Bignum Zero, One;
Bignum bignum_from_bytes(unsigned char *data, int nbytes); Bignum bignum_from_bytes(const unsigned char *data, int nbytes);
int ssh1_read_bignum(unsigned char *data, Bignum * result); int ssh1_read_bignum(const unsigned char *data, Bignum * result);
int bignum_bitcount(Bignum bn); int bignum_bitcount(Bignum bn);
int ssh1_bignum_length(Bignum bn); int ssh1_bignum_length(Bignum bn);
int ssh2_bignum_length(Bignum bn); int ssh2_bignum_length(Bignum bn);
@ -283,11 +283,11 @@ Bignum bignum_rshift(Bignum number, int shift);
int bignum_cmp(Bignum a, Bignum b); int bignum_cmp(Bignum a, Bignum b);
char *bignum_decimal(Bignum x); char *bignum_decimal(Bignum x);
void dh_setup_group1(void); void *dh_setup_group1(void);
void dh_setup_group(Bignum pval, Bignum gval); void *dh_setup_group(Bignum pval, Bignum gval);
void dh_cleanup(void); void dh_cleanup(void *);
Bignum dh_create_e(int nbits); Bignum dh_create_e(void *, int nbits);
Bignum dh_find_K(Bignum f); Bignum dh_find_K(void *, Bignum f);
int loadrsakey(char *filename, struct RSAKey *key, char *passphrase); int loadrsakey(char *filename, struct RSAKey *key, char *passphrase);
int rsakey_encrypted(char *filename, char **comment); int rsakey_encrypted(char *filename, char **comment);

6
sshbn.c
View File

@ -482,7 +482,7 @@ void decbn(Bignum bn)
bn[i]--; bn[i]--;
} }
Bignum bignum_from_bytes(unsigned char *data, int nbytes) Bignum bignum_from_bytes(const unsigned char *data, int nbytes)
{ {
Bignum result; Bignum result;
int w, i; int w, i;
@ -509,9 +509,9 @@ Bignum bignum_from_bytes(unsigned char *data, int nbytes)
* Read an ssh1-format bignum from a data buffer. Return the number * Read an ssh1-format bignum from a data buffer. Return the number
* of bytes consumed. * of bytes consumed.
*/ */
int ssh1_read_bignum(unsigned char *data, Bignum * result) int ssh1_read_bignum(const unsigned char *data, Bignum * result)
{ {
unsigned char *p = data; const unsigned char *p = data;
int i; int i;
int w, b; int w, b;

81
sshdh.c
View File

@ -11,7 +11,7 @@ const struct ssh_kex ssh_diffiehellman_gex = {
/* /*
* The prime p used in the key exchange. * The prime p used in the key exchange.
*/ */
static unsigned char P[] = { static const unsigned char P[] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1, 0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6, 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
@ -28,51 +28,62 @@ static unsigned char P[] = {
/* /*
* The generator g = 2. * The generator g = 2.
*/ */
static unsigned char G[] = { 2 }; static const unsigned char G[] = { 2 };
/* /*
* Variables. * Variables.
*/ */
static Bignum x, e, p, q, qmask, g; struct dh_ctx {
Bignum x, e, p, q, qmask, g;
};
/* /*
* Common DH initialisation. * Common DH initialisation.
*/ */
static void dh_init(void) static void dh_init(struct dh_ctx *ctx)
{ {
q = bignum_rshift(p, 1); ctx->q = bignum_rshift(ctx->p, 1);
qmask = bignum_bitmask(q); ctx->qmask = bignum_bitmask(ctx->q);
ctx->x = ctx->e = NULL;
} }
/* /*
* Initialise DH for the standard group1. * Initialise DH for the standard group1.
*/ */
void dh_setup_group1(void) void *dh_setup_group1(void)
{ {
p = bignum_from_bytes(P, sizeof(P)); struct dh_ctx *ctx = smalloc(sizeof(struct dh_ctx));
g = bignum_from_bytes(G, sizeof(G)); ctx->p = bignum_from_bytes(P, sizeof(P));
dh_init(); ctx->g = bignum_from_bytes(G, sizeof(G));
dh_init(ctx);
return ctx;
} }
/* /*
* Initialise DH for an alternative group. * Initialise DH for an alternative group.
*/ */
void dh_setup_group(Bignum pval, Bignum gval) void *dh_setup_group(Bignum pval, Bignum gval)
{ {
p = copybn(pval); struct dh_ctx *ctx = smalloc(sizeof(struct dh_ctx));
g = copybn(gval); ctx->p = copybn(pval);
dh_init(); ctx->g = copybn(gval);
dh_init(ctx);
return ctx;
} }
/* /*
* Clean up. * Clean up and free a context.
*/ */
void dh_cleanup(void) void dh_cleanup(void *handle)
{ {
freebn(p); struct dh_ctx *ctx = (struct dh_ctx *)handle;
freebn(g); freebn(ctx->x);
freebn(q); freebn(ctx->e);
freebn(qmask); freebn(ctx->p);
freebn(ctx->g);
freebn(ctx->q);
freebn(ctx->qmask);
sfree(ctx);
} }
/* /*
@ -90,14 +101,15 @@ void dh_cleanup(void)
* Advances in Cryptology: Proceedings of Eurocrypt '96 * Advances in Cryptology: Proceedings of Eurocrypt '96
* Springer-Verlag, May 1996. * Springer-Verlag, May 1996.
*/ */
Bignum dh_create_e(int nbits) Bignum dh_create_e(void *handle, int nbits)
{ {
struct dh_ctx *ctx = (struct dh_ctx *)handle;
int i; int i;
int nbytes; int nbytes;
unsigned char *buf; unsigned char *buf;
nbytes = ssh1_bignum_length(qmask); nbytes = ssh1_bignum_length(ctx->qmask);
buf = smalloc(nbytes); buf = smalloc(nbytes);
do { do {
@ -105,43 +117,44 @@ Bignum dh_create_e(int nbits)
* Create a potential x, by ANDing a string of random bytes * Create a potential x, by ANDing a string of random bytes
* with qmask. * with qmask.
*/ */
if (x) if (ctx->x)
freebn(x); freebn(ctx->x);
if (nbits == 0 || nbits > bignum_bitcount(qmask)) { if (nbits == 0 || nbits > bignum_bitcount(ctx->qmask)) {
ssh1_write_bignum(buf, qmask); ssh1_write_bignum(buf, ctx->qmask);
for (i = 2; i < nbytes; i++) for (i = 2; i < nbytes; i++)
buf[i] &= random_byte(); buf[i] &= random_byte();
ssh1_read_bignum(buf, &x); ssh1_read_bignum(buf, &ctx->x);
} else { } else {
int b, nb; int b, nb;
x = bn_power_2(nbits); ctx->x = bn_power_2(nbits);
b = nb = 0; b = nb = 0;
for (i = 0; i < nbits; i++) { for (i = 0; i < nbits; i++) {
if (nb == 0) { if (nb == 0) {
nb = 8; nb = 8;
b = random_byte(); b = random_byte();
} }
bignum_set_bit(x, i, b & 1); bignum_set_bit(ctx->x, i, b & 1);
b >>= 1; b >>= 1;
nb--; nb--;
} }
} }
} while (bignum_cmp(x, One) <= 0 || bignum_cmp(x, q) >= 0); } while (bignum_cmp(ctx->x, One) <= 0 || bignum_cmp(ctx->x, ctx->q) >= 0);
/* /*
* Done. Now compute e = g^x mod p. * Done. Now compute e = g^x mod p.
*/ */
e = modpow(g, x, p); ctx->e = modpow(ctx->g, ctx->x, ctx->p);
return e; return ctx->e;
} }
/* /*
* DH stage 2: given a number f, compute K = f^x mod p. * DH stage 2: given a number f, compute K = f^x mod p.
*/ */
Bignum dh_find_K(Bignum f) Bignum dh_find_K(void *handle, Bignum f)
{ {
struct dh_ctx *ctx = (struct dh_ctx *)handle;
Bignum ret; Bignum ret;
ret = modpow(f, x, p); ret = modpow(f, ctx->x, ctx->p);
return ret; return ret;
} }