nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-07-02 03:52:49 -05: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
Download Patch File Download Diff File Expand all files Collapse all files

81
sshdh.c
View File

@ -11,7 +11,7 @@ const struct ssh_kex ssh_diffiehellman_gex = {
/*
* 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,
0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
@ -28,51 +28,62 @@ static unsigned char P[] = {
/*
* The generator g = 2.
*/
static unsigned char G[] = { 2 };
static const unsigned char G[] = { 2 };
/*
* Variables.
*/
static Bignum x, e, p, q, qmask, g;
struct dh_ctx {
Bignum x, e, p, q, qmask, g;
};
/*
* Common DH initialisation.
*/
static void dh_init(void)
static void dh_init(struct dh_ctx *ctx)
{
q = bignum_rshift(p, 1);
qmask = bignum_bitmask(q);
ctx->q = bignum_rshift(ctx->p, 1);
ctx->qmask = bignum_bitmask(ctx->q);
ctx->x = ctx->e = NULL;
}
/*
* Initialise DH for the standard group1.
*/
void dh_setup_group1(void)
void *dh_setup_group1(void)
{
p = bignum_from_bytes(P, sizeof(P));
g = bignum_from_bytes(G, sizeof(G));
dh_init();
struct dh_ctx *ctx = smalloc(sizeof(struct dh_ctx));
ctx->p = bignum_from_bytes(P, sizeof(P));
ctx->g = bignum_from_bytes(G, sizeof(G));
dh_init(ctx);
return ctx;
}
/*
* 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);
g = copybn(gval);
dh_init();
struct dh_ctx *ctx = smalloc(sizeof(struct dh_ctx));
ctx->p = copybn(pval);
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);
freebn(g);
freebn(q);
freebn(qmask);
struct dh_ctx *ctx = (struct dh_ctx *)handle;
freebn(ctx->x);
freebn(ctx->e);
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
* 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 nbytes;
unsigned char *buf;
nbytes = ssh1_bignum_length(qmask);
nbytes = ssh1_bignum_length(ctx->qmask);
buf = smalloc(nbytes);
do {
@ -105,43 +117,44 @@ Bignum dh_create_e(int nbits)
* Create a potential x, by ANDing a string of random bytes
* with qmask.
*/
if (x)
freebn(x);
if (nbits == 0 || nbits > bignum_bitcount(qmask)) {
ssh1_write_bignum(buf, qmask);
if (ctx->x)
freebn(ctx->x);
if (nbits == 0 || nbits > bignum_bitcount(ctx->qmask)) {
ssh1_write_bignum(buf, ctx->qmask);
for (i = 2; i < nbytes; i++)
buf[i] &= random_byte();
ssh1_read_bignum(buf, &x);
ssh1_read_bignum(buf, &ctx->x);
} else {
int b, nb;
x = bn_power_2(nbits);
ctx->x = bn_power_2(nbits);
b = nb = 0;
for (i = 0; i < nbits; i++) {
if (nb == 0) {
nb = 8;
b = random_byte();
}
bignum_set_bit(x, i, b & 1);
bignum_set_bit(ctx->x, i, b & 1);
b >>= 1;
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.
*/
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.
*/
Bignum dh_find_K(Bignum f)
Bignum dh_find_K(void *handle, Bignum f)
{
struct dh_ctx *ctx = (struct dh_ctx *)handle;
Bignum ret;
ret = modpow(f, x, p);
ret = modpow(f, ctx->x, ctx->p);
return ret;
}