mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-09 17:38:00 +00:00
RSA key authentication in ssh1 works; SSH2 is nearly there
[originally from svn r572]
This commit is contained in:
Simon Tatham
parent
0f1e449189
commit
d9af8f4b90
3
Makefile
3
Makefile
@ -58,7 +58,7 @@ MOBJS = misc.$(OBJ) version.$(OBJ)
|
||||
##-- objects putty pscp
|
||||
OBJS1 = sshcrc.$(OBJ) sshdes.$(OBJ) sshmd5.$(OBJ) sshrsa.$(OBJ) sshrand.$(OBJ)
|
||||
OBJS2 = sshsha.$(OBJ) sshblowf.$(OBJ) noise.$(OBJ) sshdh.$(OBJ) sshdss.$(OBJ)
|
||||
OBJS3 = sshbn.$(OBJ)
|
||||
OBJS3 = sshbn.$(OBJ) sshpubk.$(OBJ)
|
||||
##-- resources putty
|
||||
PRESRC = win_res.$(RES)
|
||||
##-- resources puttytel
|
||||
@ -144,6 +144,7 @@ sshblowf.$(OBJ): sshblowf.c ssh.h
|
||||
sshdh.$(OBJ): sshdh.c ssh.h
|
||||
sshdss.$(OBJ): sshdss.c ssh.h
|
||||
sshbn.$(OBJ): sshbn.c ssh.h
|
||||
sshpubk.$(OBJ): sshpubk.c ssh.h
|
||||
scp.$(OBJ): scp.c putty.h scp.h
|
||||
version.$(OBJ): version.c
|
||||
be_all.$(OBJ): be_all.c
|
||||
|
||||
1
putty.h
1
putty.h
@ -135,6 +135,7 @@ typedef struct {
|
||||
/* SSH options */
|
||||
int nopty;
|
||||
enum { CIPHER_3DES, CIPHER_BLOWFISH, CIPHER_DES } cipher;
|
||||
char keyfile[FILENAME_MAX];
|
||||
int try_tis_auth;
|
||||
/* Telnet options */
|
||||
char termtype[32];
|
||||
|
||||
47
ssh.h
47
ssh.h
@ -18,6 +18,13 @@
|
||||
#define APIEXTRA 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
* A Bignum is stored as a sequence of `unsigned short' words. The
|
||||
* first tells how many remain; the remaining ones are digits, LS
|
||||
* first.
|
||||
*/
|
||||
typedef unsigned short *Bignum;
|
||||
|
||||
struct RSAKey {
|
||||
int bits;
|
||||
int bytes;
|
||||
@ -25,14 +32,19 @@ struct RSAKey {
|
||||
unsigned long exponent;
|
||||
unsigned char *modulus;
|
||||
#else
|
||||
void *modulus;
|
||||
void *exponent;
|
||||
Bignum modulus;
|
||||
Bignum exponent;
|
||||
Bignum private_exponent;
|
||||
#endif
|
||||
};
|
||||
|
||||
int makekey(unsigned char *data, struct RSAKey *result,
|
||||
unsigned char **keystr);
|
||||
unsigned char **keystr, int order);
|
||||
int makeprivate(unsigned char *data, struct RSAKey *result);
|
||||
void rsaencrypt(unsigned char *data, int length, struct RSAKey *key);
|
||||
Bignum rsadecrypt(Bignum input, struct RSAKey *key);
|
||||
void rsasign(unsigned char *data, int length, struct RSAKey *key);
|
||||
void rsasanitise(struct RSAKey *key);
|
||||
int rsastr_len(struct RSAKey *key);
|
||||
void rsastr_fmt(char *str, struct RSAKey *key);
|
||||
|
||||
@ -71,6 +83,7 @@ typedef struct {
|
||||
void SHA_Init(SHA_State *s);
|
||||
void SHA_Bytes(SHA_State *s, void *p, int len);
|
||||
void SHA_Final(SHA_State *s, unsigned char *output);
|
||||
void SHA_Simple(void *p, int len, unsigned char *output);
|
||||
|
||||
struct ssh_cipher {
|
||||
void (*sesskey)(unsigned char *key); /* for ssh 1 */
|
||||
@ -94,10 +107,20 @@ struct ssh_mac {
|
||||
};
|
||||
|
||||
struct ssh_kex {
|
||||
/*
|
||||
* Plugging in another KEX algorithm requires structural chaos,
|
||||
* so it's hard to abstract them into nice little structures
|
||||
* like this. Hence, for the moment, this is just a
|
||||
* placeholder. I claim justification in the fact that OpenSSH
|
||||
* does this too :-)
|
||||
*/
|
||||
char *name;
|
||||
};
|
||||
|
||||
struct ssh_hostkey {
|
||||
void (*setkey)(char *data, int len);
|
||||
char *(*fmtkey)(void);
|
||||
int (*verifysig)(char *sig, int siglen, char *data, int datalen);
|
||||
char *name;
|
||||
};
|
||||
|
||||
@ -114,16 +137,20 @@ void random_add_noise(void *noise, int length);
|
||||
|
||||
void logevent (char *);
|
||||
|
||||
/*
|
||||
* A Bignum is stored as a sequence of `unsigned short' words. The
|
||||
* first tells how many remain; the remaining ones are digits, LS
|
||||
* first.
|
||||
*/
|
||||
typedef unsigned short *Bignum;
|
||||
|
||||
Bignum newbn(int length);
|
||||
Bignum copybn(Bignum b);
|
||||
void freebn(Bignum b);
|
||||
void modpow(Bignum base, Bignum exp, Bignum mod, Bignum result);
|
||||
void modmul(Bignum a, Bignum b, Bignum mod, Bignum result);
|
||||
void decbn(Bignum n);
|
||||
extern Bignum Zero, One;
|
||||
int ssh1_read_bignum(unsigned char *data, Bignum *result);
|
||||
|
||||
Bignum dh_create_e(void);
|
||||
Bignum dh_find_K(Bignum f);
|
||||
|
||||
int loadrsakey(char *filename, struct RSAKey *key, char *passphrase);
|
||||
int rsakey_encrypted(char *filename);
|
||||
|
||||
void des3_decrypt_pubkey(unsigned char *key,
|
||||
unsigned char *blk, int len);
|
||||
171
sshbn.c
171
sshbn.c
@ -6,36 +6,17 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <stdio.h> /* FIXME */
|
||||
#include <stdarg.h> /* FIXME */
|
||||
#include <windows.h> /* FIXME */
|
||||
#include "putty.h" /* FIXME */
|
||||
|
||||
#include "ssh.h"
|
||||
|
||||
static unsigned short Zero[1] = { 0 };
|
||||
unsigned short bnZero[1] = { 0 };
|
||||
unsigned short bnOne[2] = { 1, 1 };
|
||||
|
||||
#if defined TESTMODE || defined RSADEBUG
|
||||
#ifndef DLVL
|
||||
#define DLVL 10000
|
||||
#endif
|
||||
#define debug(x) bndebug(#x,x)
|
||||
static int level = 0;
|
||||
static void bndebug(char *name, Bignum b) {
|
||||
int i;
|
||||
int w = 50-level-strlen(name)-5*b[0];
|
||||
if (level >= DLVL)
|
||||
return;
|
||||
if (w < 0) w = 0;
|
||||
dprintf("%*s%s%*s", level, "", name, w, "");
|
||||
for (i=b[0]; i>0; i--)
|
||||
dprintf(" %04x", b[i]);
|
||||
dprintf("\n");
|
||||
}
|
||||
#define dmsg(x) do {if(level<DLVL){dprintf("%*s",level,"");printf x;}} while(0)
|
||||
#define enter(x) do { dmsg(x); level += 4; } while(0)
|
||||
#define leave(x) do { level -= 4; dmsg(x); } while(0)
|
||||
#else
|
||||
#define debug(x)
|
||||
#define dmsg(x)
|
||||
#define enter(x)
|
||||
#define leave(x)
|
||||
#endif
|
||||
Bignum Zero = bnZero, One = bnOne;
|
||||
|
||||
Bignum newbn(int length) {
|
||||
Bignum b = malloc((length+1)*sizeof(unsigned short));
|
||||
@ -46,6 +27,14 @@ Bignum newbn(int length) {
|
||||
return b;
|
||||
}
|
||||
|
||||
Bignum copybn(Bignum orig) {
|
||||
Bignum b = malloc((orig[0]+1)*sizeof(unsigned short));
|
||||
if (!b)
|
||||
abort(); /* FIXME */
|
||||
memcpy(b, orig, (orig[0]+1)*sizeof(*b));
|
||||
return b;
|
||||
}
|
||||
|
||||
void freebn(Bignum b) {
|
||||
/*
|
||||
* Burn the evidence, just in case.
|
||||
@ -83,11 +72,13 @@ static void bigmul(unsigned short *a, unsigned short *b, unsigned short *c,
|
||||
|
||||
/*
|
||||
* Compute a = a % m.
|
||||
* Input in first 2*len words of a and first len words of m.
|
||||
* Output in first 2*len words of a (of which first len words will be zero).
|
||||
* Input in first len2 words of a and first len words of m.
|
||||
* Output in first len2 words of a
|
||||
* (of which first len2-len words will be zero).
|
||||
* The MSW of m MUST have its high bit set.
|
||||
*/
|
||||
static void bigmod(unsigned short *a, unsigned short *m, int len)
|
||||
static void bigmod(unsigned short *a, unsigned short *m,
|
||||
int len, int len2)
|
||||
{
|
||||
unsigned short m0, m1;
|
||||
unsigned int h;
|
||||
@ -103,7 +94,7 @@ static void bigmod(unsigned short *a, unsigned short *m, int len)
|
||||
m0 = m[0];
|
||||
m1 = m[1];
|
||||
|
||||
for (i = 0; i <= len; i++) {
|
||||
for (i = 0; i <= len2-len; i++) {
|
||||
unsigned long t;
|
||||
unsigned int q, r, c;
|
||||
|
||||
@ -204,10 +195,10 @@ void modpow(Bignum base, Bignum exp, Bignum mod, Bignum result)
|
||||
while (i < exp[0]) {
|
||||
while (j >= 0) {
|
||||
bigmul(a + mlen, a + mlen, b, mlen);
|
||||
bigmod(b, m, mlen);
|
||||
bigmod(b, m, mlen, mlen*2);
|
||||
if ((exp[exp[0] - i] & (1 << j)) != 0) {
|
||||
bigmul(b + mlen, n, a, mlen);
|
||||
bigmod(a, m, mlen);
|
||||
bigmod(a, m, mlen, mlen*2);
|
||||
} else {
|
||||
unsigned short *t;
|
||||
t = a; a = b; b = t;
|
||||
@ -222,7 +213,7 @@ void modpow(Bignum base, Bignum exp, Bignum mod, Bignum result)
|
||||
for (i = mlen - 1; i < 2*mlen - 1; i++)
|
||||
a[i] = (a[i] << mshift) | (a[i+1] >> (16-mshift));
|
||||
a[2*mlen-1] = a[2*mlen-1] << mshift;
|
||||
bigmod(a, m, mlen);
|
||||
bigmod(a, m, mlen, mlen*2);
|
||||
for (i = 2*mlen - 1; i >= mlen; i--)
|
||||
a[i] = (a[i] >> mshift) | (a[i-1] << (16-mshift));
|
||||
}
|
||||
@ -237,3 +228,115 @@ void modpow(Bignum base, Bignum exp, Bignum mod, Bignum result)
|
||||
for (i = 0; i < mlen; i++) m[i] = 0; free(m);
|
||||
for (i = 0; i < mlen; i++) n[i] = 0; free(n);
|
||||
}
|
||||
|
||||
/*
|
||||
* Compute (p * q) % mod.
|
||||
* The most significant word of mod MUST be non-zero.
|
||||
* We assume that the result array is the same size as the mod array.
|
||||
*/
|
||||
void modmul(Bignum p, Bignum q, Bignum mod, Bignum result)
|
||||
{
|
||||
unsigned short *a, *n, *m, *o;
|
||||
int mshift;
|
||||
int pqlen, mlen, i, j;
|
||||
|
||||
/* Allocate m of size mlen, copy mod to m */
|
||||
/* We use big endian internally */
|
||||
mlen = mod[0];
|
||||
m = malloc(mlen * sizeof(unsigned short));
|
||||
for (j = 0; j < mlen; j++) m[j] = mod[mod[0] - j];
|
||||
|
||||
/* Shift m left to make msb bit set */
|
||||
for (mshift = 0; mshift < 15; mshift++)
|
||||
if ((m[0] << mshift) & 0x8000) break;
|
||||
if (mshift) {
|
||||
for (i = 0; i < mlen - 1; i++)
|
||||
m[i] = (m[i] << mshift) | (m[i+1] >> (16-mshift));
|
||||
m[mlen-1] = m[mlen-1] << mshift;
|
||||
}
|
||||
|
||||
pqlen = (p[0] > q[0] ? p[0] : q[0]);
|
||||
|
||||
/* Allocate n of size pqlen, copy p to n */
|
||||
n = malloc(pqlen * sizeof(unsigned short));
|
||||
i = pqlen - p[0];
|
||||
for (j = 0; j < i; j++) n[j] = 0;
|
||||
for (j = 0; j < p[0]; j++) n[i+j] = p[p[0] - j];
|
||||
|
||||
/* Allocate o of size pqlen, copy q to o */
|
||||
o = malloc(pqlen * sizeof(unsigned short));
|
||||
i = pqlen - q[0];
|
||||
for (j = 0; j < i; j++) o[j] = 0;
|
||||
for (j = 0; j < q[0]; j++) o[i+j] = q[q[0] - j];
|
||||
|
||||
/* Allocate a of size 2*pqlen for result */
|
||||
a = malloc(2 * pqlen * sizeof(unsigned short));
|
||||
|
||||
/* Main computation */
|
||||
bigmul(n, o, a, pqlen);
|
||||
bigmod(a, m, mlen, 2*pqlen);
|
||||
|
||||
/* Fixup result in case the modulus was shifted */
|
||||
if (mshift) {
|
||||
for (i = 2*pqlen - mlen - 1; i < 2*pqlen - 1; i++)
|
||||
a[i] = (a[i] << mshift) | (a[i+1] >> (16-mshift));
|
||||
a[2*pqlen-1] = a[2*pqlen-1] << mshift;
|
||||
bigmod(a, m, mlen, pqlen*2);
|
||||
for (i = 2*pqlen - 1; i >= 2*pqlen - mlen; i--)
|
||||
a[i] = (a[i] >> mshift) | (a[i-1] << (16-mshift));
|
||||
}
|
||||
|
||||
/* Copy result to buffer */
|
||||
for (i = 0; i < mlen; i++)
|
||||
result[result[0] - i] = a[i+2*pqlen-mlen];
|
||||
|
||||
/* Free temporary arrays */
|
||||
for (i = 0; i < 2*pqlen; i++) a[i] = 0; free(a);
|
||||
for (i = 0; i < mlen; i++) m[i] = 0; free(m);
|
||||
for (i = 0; i < pqlen; i++) n[i] = 0; free(n);
|
||||
for (i = 0; i < pqlen; i++) o[i] = 0; free(o);
|
||||
}
|
||||
|
||||
/*
|
||||
* Decrement a number.
|
||||
*/
|
||||
void decbn(Bignum bn) {
|
||||
int i = 1;
|
||||
while (i < bn[0] && bn[i] == 0)
|
||||
bn[i++] = 0xFFFF;
|
||||
bn[i]--;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read an ssh1-format bignum from a data buffer. Return the number
|
||||
* of bytes consumed.
|
||||
*/
|
||||
int ssh1_read_bignum(unsigned char *data, Bignum *result) {
|
||||
unsigned char *p = data;
|
||||
Bignum bn;
|
||||
int i;
|
||||
int w, b;
|
||||
|
||||
w = 0;
|
||||
for (i=0; i<2; i++)
|
||||
w = (w << 8) + *p++;
|
||||
|
||||
b = (w+7)/8; /* bits -> bytes */
|
||||
w = (w+15)/16; /* bits -> words */
|
||||
|
||||
bn = newbn(w);
|
||||
|
||||
for (i=1; i<=w; i++)
|
||||
bn[i] = 0;
|
||||
for (i=b; i-- ;) {
|
||||
unsigned char byte = *p++;
|
||||
if (i & 1)
|
||||
bn[1+i/2] |= byte<<8;
|
||||
else
|
||||
bn[1+i/2] |= byte;
|
||||
}
|
||||
|
||||
*result = bn;
|
||||
|
||||
return p - data;
|
||||
}
|
||||
|
||||
13
sshdes.c
13
sshdes.c
@ -1,4 +1,5 @@
|
||||
#include <assert.h>
|
||||
#include <stdio.h> /* FIXME */
|
||||
#include <stdarg.h> /* FIXME */
|
||||
#include <windows.h> /* FIXME */
|
||||
#include "putty.h" /* FIXME */
|
||||
@ -769,6 +770,18 @@ static void des3_ssh2_decrypt_blk(unsigned char *blk, int len) {
|
||||
des_cbc3_decrypt(blk, blk, len, sckeys);
|
||||
}
|
||||
|
||||
void des3_decrypt_pubkey(unsigned char *key,
|
||||
unsigned char *blk, int len) {
|
||||
DESContext ourkeys[3];
|
||||
des_key_setup(GET_32BIT_MSB_FIRST(key),
|
||||
GET_32BIT_MSB_FIRST(key+4), &ourkeys[0]);
|
||||
des_key_setup(GET_32BIT_MSB_FIRST(key+8),
|
||||
GET_32BIT_MSB_FIRST(key+12), &ourkeys[1]);
|
||||
des_key_setup(GET_32BIT_MSB_FIRST(key),
|
||||
GET_32BIT_MSB_FIRST(key+4), &ourkeys[2]);
|
||||
des_3cbc_decrypt(blk, blk, len, ourkeys);
|
||||
}
|
||||
|
||||
struct ssh_cipher ssh_3des_ssh2 = {
|
||||
NULL,
|
||||
des3_csiv, des3_cskey,
|
||||
|
||||
184
sshdss.c
184
sshdss.c
@ -1,5 +1,189 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "ssh.h"
|
||||
|
||||
#define GET_32BIT(cp) \
|
||||
(((unsigned long)(unsigned char)(cp)[0] << 24) | \
|
||||
((unsigned long)(unsigned char)(cp)[1] << 16) | \
|
||||
((unsigned long)(unsigned char)(cp)[2] << 8) | \
|
||||
((unsigned long)(unsigned char)(cp)[3]))
|
||||
|
||||
static void getstring(char **data, int *datalen, char **p, int *length) {
|
||||
*p = NULL;
|
||||
if (*datalen < 4)
|
||||
return;
|
||||
*length = GET_32BIT(*data);
|
||||
*datalen -= 4; *data += 4;
|
||||
if (*datalen < *length)
|
||||
return;
|
||||
*p = *data;
|
||||
*data += *length; *datalen -= *length;
|
||||
}
|
||||
static Bignum getmp(char **data, int *datalen) {
|
||||
char *p;
|
||||
int i, j, length;
|
||||
Bignum b;
|
||||
|
||||
getstring(data, datalen, &p, &length);
|
||||
if (!p)
|
||||
return NULL;
|
||||
if (p[0] & 0x80)
|
||||
return NULL; /* negative mp */
|
||||
b = newbn((length+1)/2);
|
||||
for (i = 0; i < length; i++) {
|
||||
j = length - 1 - i;
|
||||
if (j & 1)
|
||||
b[j/2+1] |= ((unsigned char)p[i]) << 8;
|
||||
else
|
||||
b[j/2+1] |= ((unsigned char)p[i]);
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
static Bignum get160(char **data, int *datalen) {
|
||||
char *p;
|
||||
int i, j, length;
|
||||
Bignum b;
|
||||
|
||||
p = *data;
|
||||
*data += 20; *datalen -= 20;
|
||||
|
||||
length = 20;
|
||||
while (length > 0 && !p[0])
|
||||
p++, length--;
|
||||
b = newbn((length+1)/2);
|
||||
for (i = 0; i < length; i++) {
|
||||
j = length - 1 - i;
|
||||
if (j & 1)
|
||||
b[j/2+1] |= ((unsigned char)p[i]) << 8;
|
||||
else
|
||||
b[j/2+1] |= ((unsigned char)p[i]);
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
static Bignum dss_p, dss_q, dss_g, dss_y;
|
||||
|
||||
static void dss_setkey(char *data, int len) {
|
||||
char *p;
|
||||
int slen;
|
||||
getstring(&data, &len, &p, &slen);
|
||||
if (!p || memcmp(p, "ssh-dss", 7)) {
|
||||
dss_p = NULL;
|
||||
return;
|
||||
}
|
||||
dss_p = getmp(&data, &len);
|
||||
dss_q = getmp(&data, &len);
|
||||
dss_g = getmp(&data, &len);
|
||||
dss_y = getmp(&data, &len);
|
||||
}
|
||||
|
||||
static char *dss_fmtkey(void) {
|
||||
char *p;
|
||||
int len;
|
||||
int i;
|
||||
if (!dss_p)
|
||||
return NULL;
|
||||
len = 7 + 4 + 1; /* "ssh-dss", punctuation, \0 */
|
||||
len += 4 * (dss_p[0] + dss_q[0] + dss_g[0] + dss_y[0]); /* digits */
|
||||
p = malloc(len);
|
||||
if (!p) return NULL;
|
||||
strcpy(p, "ssh-dss:");
|
||||
for (i = dss_p[0]; i > 0; i--) sprintf(p+strlen(p), "%04X", dss_p[i]);
|
||||
strcat(p, "/");
|
||||
for (i = dss_q[0]; i > 0; i--) sprintf(p+strlen(p), "%04X", dss_q[i]);
|
||||
strcat(p, "/");
|
||||
for (i = dss_g[0]; i > 0; i--) sprintf(p+strlen(p), "%04X", dss_g[i]);
|
||||
strcat(p, "/");
|
||||
for (i = dss_y[0]; i > 0; i--) sprintf(p+strlen(p), "%04X", dss_y[i]);
|
||||
return p;
|
||||
}
|
||||
|
||||
static int dss_verifysig(char *sig, int siglen, char *data, int datalen) {
|
||||
char *p;
|
||||
int i, slen;
|
||||
char hash[20];
|
||||
Bignum qm2, r, s, w, i1, i2, i3, u1, u2, sha, v;
|
||||
int ret;
|
||||
|
||||
if (!dss_p)
|
||||
return 0;
|
||||
|
||||
getstring(&sig, &siglen, &p, &slen);
|
||||
if (!p || memcmp(p, "ssh-dss", 7)) {
|
||||
return 0;
|
||||
}
|
||||
sig += 4, siglen -= 4; /* skip yet another length field */
|
||||
r = get160(&sig, &siglen);
|
||||
s = get160(&sig, &siglen);
|
||||
if (!r || !s)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* Step 1. w <- s^-1 mod q.
|
||||
*/
|
||||
w = newbn(dss_q[0]);
|
||||
qm2 = copybn(dss_q);
|
||||
decbn(qm2); decbn(qm2);
|
||||
/* Now qm2 is q-2, and by Fermat's Little Theorem, s^qm2 == s^-1 (mod q).
|
||||
* This is a silly way to do it; may fix it later. */
|
||||
modpow(s, qm2, dss_q, w);
|
||||
|
||||
/*
|
||||
* Step 2. u1 <- SHA(message) * w mod q.
|
||||
*/
|
||||
u1 = newbn(dss_q[0]);
|
||||
SHA_Simple(data, datalen, hash);
|
||||
p = hash; slen = 20; sha = get160(&p, &slen);
|
||||
modmul(sha, w, dss_q, u1);
|
||||
|
||||
/*
|
||||
* Step 3. u2 <- r * w mod q.
|
||||
*/
|
||||
u2 = newbn(dss_q[0]);
|
||||
modmul(r, w, dss_q, u2);
|
||||
|
||||
/*
|
||||
* Step 4. v <- (g^u1 * y^u2 mod p) mod q.
|
||||
*/
|
||||
i1 = newbn(dss_p[0]);
|
||||
i2 = newbn(dss_p[0]);
|
||||
i3 = newbn(dss_p[0]);
|
||||
v = newbn(dss_q[0]);
|
||||
modpow(dss_g, u1, dss_p, i1);
|
||||
modpow(dss_y, u2, dss_p, i2);
|
||||
modmul(i1, i2, dss_p, i3);
|
||||
modmul(i3, One, dss_q, v);
|
||||
|
||||
/*
|
||||
* Step 5. v should now be equal to r.
|
||||
*/
|
||||
|
||||
ret = 1;
|
||||
for (i = 1; i <= v[0] || i <= r[0]; i++) {
|
||||
if ((i > v[0] && r[i] != 0) ||
|
||||
(i > r[0] && v[i] != 0) ||
|
||||
(i <= v[0] && i <= r[0] && r[i] != v[i]))
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
freebn(w);
|
||||
freebn(qm2);
|
||||
freebn(sha);
|
||||
freebn(i1);
|
||||
freebn(i2);
|
||||
freebn(i3);
|
||||
freebn(v);
|
||||
freebn(r);
|
||||
freebn(s);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct ssh_hostkey ssh_dss = {
|
||||
dss_setkey,
|
||||
dss_fmtkey,
|
||||
dss_verifysig,
|
||||
"ssh-dss"
|
||||
};
|
||||
|
||||
57
sshrsa.c
57
sshrsa.c
@ -39,49 +39,35 @@ static void bndebug(char *name, Bignum b) {
|
||||
#include "ssh.h"
|
||||
|
||||
int makekey(unsigned char *data, struct RSAKey *result,
|
||||
unsigned char **keystr) {
|
||||
unsigned char **keystr, int order) {
|
||||
unsigned char *p = data;
|
||||
Bignum bn[2];
|
||||
int i, j;
|
||||
int w, b;
|
||||
int i;
|
||||
|
||||
result->bits = 0;
|
||||
for (i=0; i<4; i++)
|
||||
result->bits = (result->bits << 8) + *p++;
|
||||
|
||||
for (j=0; j<2; j++) {
|
||||
/*
|
||||
* order=0 means exponent then modulus (the keys sent by the
|
||||
* server). order=1 means modulus then exponent (the keys
|
||||
* stored in a keyfile).
|
||||
*/
|
||||
|
||||
w = 0;
|
||||
for (i=0; i<2; i++)
|
||||
w = (w << 8) + *p++;
|
||||
|
||||
result->bytes = b = (w+7)/8; /* bits -> bytes */
|
||||
w = (w+15)/16; /* bits -> words */
|
||||
|
||||
bn[j] = newbn(w);
|
||||
|
||||
if (keystr) *keystr = p; /* point at key string, second time */
|
||||
|
||||
for (i=1; i<=w; i++)
|
||||
bn[j][i] = 0;
|
||||
for (i=b; i-- ;) {
|
||||
unsigned char byte = *p++;
|
||||
if (i & 1)
|
||||
bn[j][1+i/2] |= byte<<8;
|
||||
else
|
||||
bn[j][1+i/2] |= byte;
|
||||
}
|
||||
|
||||
debug(bn[j]);
|
||||
|
||||
}
|
||||
|
||||
result->exponent = bn[0];
|
||||
result->modulus = bn[1];
|
||||
if (order == 0)
|
||||
p += ssh1_read_bignum(p, &result->exponent);
|
||||
result->bytes = (((p[0] << 8) + p[1]) + 7) / 8;
|
||||
if (keystr) *keystr = p+2;
|
||||
p += ssh1_read_bignum(p, &result->modulus);
|
||||
if (order == 1)
|
||||
p += ssh1_read_bignum(p, &result->exponent);
|
||||
|
||||
return p - data;
|
||||
}
|
||||
|
||||
int makeprivate(unsigned char *data, struct RSAKey *result) {
|
||||
return ssh1_read_bignum(data, &result->private_exponent);
|
||||
}
|
||||
|
||||
void rsaencrypt(unsigned char *data, int length, struct RSAKey *key) {
|
||||
Bignum b1, b2;
|
||||
int w, i;
|
||||
@ -136,6 +122,13 @@ void rsaencrypt(unsigned char *data, int length, struct RSAKey *key) {
|
||||
freebn(b2);
|
||||
}
|
||||
|
||||
Bignum rsadecrypt(Bignum input, struct RSAKey *key) {
|
||||
Bignum ret;
|
||||
ret = newbn(key->modulus[0]);
|
||||
modpow(input, key->private_exponent, key->modulus, ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int rsastr_len(struct RSAKey *key) {
|
||||
Bignum md, ex;
|
||||
|
||||
|
||||
29
sshsha.c
29
sshsha.c
@ -1,7 +1,3 @@
|
||||
#include <stdarg.h> /* FIXME */
|
||||
#include <windows.h> /* FIXME */
|
||||
#include "putty.h" /* FIXME */
|
||||
|
||||
/*
|
||||
* SHA1 hash algorithm. Used in SSH2 as a MAC, and the transform is
|
||||
* also used as a `stirring' function for the PuTTY random number
|
||||
@ -181,11 +177,6 @@ static void sha1_key(SHA_State *s1, SHA_State *s2,
|
||||
unsigned char *key, int len) {
|
||||
unsigned char foo[64];
|
||||
int i;
|
||||
{int j;
|
||||
debug(("Key supplied is:\r\n"));
|
||||
for (j=0; j<len; j++) debug((" %02X", key[j]));
|
||||
debug(("\r\n"));
|
||||
}
|
||||
|
||||
memset(foo, 0x36, 64);
|
||||
for (i = 0; i < len && i < 64; i++)
|
||||
@ -231,32 +222,12 @@ static void sha1_do_hmac(SHA_State *s1, SHA_State *s2,
|
||||
}
|
||||
|
||||
static void sha1_generate(unsigned char *blk, int len, unsigned long seq) {
|
||||
{int i;
|
||||
debug(("Gen HMAC on block len=%d seq=%d:\r\n", len, seq));
|
||||
for (i=0; i<len; i++) debug((" %02X", blk[i]));
|
||||
debug(("\r\n"));
|
||||
}
|
||||
sha1_do_hmac(&sha1_cs_mac_s1, &sha1_cs_mac_s2, blk, len, seq, blk+len);
|
||||
{int i;
|
||||
debug(("We compute HMAC as:\r\n"));
|
||||
for (i=0; i<20; i++) debug((" %02X", blk[len+i]));
|
||||
debug(("\r\n"));
|
||||
}
|
||||
}
|
||||
|
||||
static int sha1_verify(unsigned char *blk, int len, unsigned long seq) {
|
||||
unsigned char correct[20];
|
||||
{int i;
|
||||
debug(("HMAC on block len=%d seq=%d:\r\n", len, seq));
|
||||
for (i=0; i<len; i++) debug((" %02X", blk[i]));
|
||||
debug(("\r\n"));
|
||||
}
|
||||
sha1_do_hmac(&sha1_sc_mac_s1, &sha1_sc_mac_s2, blk, len, seq, correct);
|
||||
{int i;
|
||||
debug(("We compute HMAC as:\r\n"));
|
||||
for (i=0; i<20; i++) debug((" %02X", correct[i]));
|
||||
debug(("\r\n"));
|
||||
}
|
||||
return !memcmp(correct, blk+len, 20);
|
||||
}
|
||||
|
||||
|
||||
@ -111,6 +111,9 @@
|
||||
#define IDC3_CIPHERBLOWF 1021
|
||||
#define IDC3_CIPHERDES 1022
|
||||
#define IDC3_AUTHTIS 1023
|
||||
#define IDC3_PKSTATIC 1024
|
||||
#define IDC3_PKEDIT 1025
|
||||
#define IDC3_PKBUTTON 1026
|
||||
|
||||
#define IDC4_MBSTATIC 1001
|
||||
#define IDC4_MBWINDOWS 1002
|
||||
|
||||
@ -236,6 +236,12 @@ BEGIN
|
||||
|
||||
|
||||
AUTOCHECKBOX "Attempt TIS authentication", IDC3_AUTHTIS, 3, 55, 162, 8
|
||||
|
||||
|
||||
LTEXT "Public key file:", IDC3_PKSTATIC, 3, 75, 119, 8
|
||||
EDITTEXT IDC3_PKEDIT, 3, 83, 119, 12, ES_AUTOHSCROLL
|
||||
|
||||
PUSHBUTTON "C&hange...", IDC3_PKBUTTON, 129, 83, 35, 12
|
||||
END
|
||||
|
||||
IDD_PANEL4 DIALOG DISCARDABLE 6, 30, 168, 163
|
||||
|
||||
36
windlg.c
36
windlg.c
@ -152,6 +152,7 @@ static void save_settings (char *section, int do_host) {
|
||||
wpps (sesskey, "Cipher", cfg.cipher == CIPHER_BLOWFISH ? "blowfish" :
|
||||
cfg.cipher == CIPHER_DES ? "des" : "3des");
|
||||
wppi (sesskey, "AuthTIS", cfg.try_tis_auth);
|
||||
wpps (sesskey, "PublicKeyFile", cfg.keyfile);
|
||||
wppi (sesskey, "RFCEnviron", cfg.rfc_environ);
|
||||
wppi (sesskey, "BackspaceIsDelete", cfg.bksp_is_delete);
|
||||
wppi (sesskey, "RXVTHomeEnd", cfg.rxvt_homeend);
|
||||
@ -293,6 +294,7 @@ static void load_settings (char *section, int do_host) {
|
||||
cfg.cipher = CIPHER_3DES;
|
||||
}
|
||||
gppi (sesskey, "AuthTIS", 0, &cfg.try_tis_auth);
|
||||
gpps (sesskey, "PublicKeyFile", "", cfg.keyfile, sizeof(cfg.keyfile));
|
||||
gppi (sesskey, "RFCEnviron", 0, &cfg.rfc_environ);
|
||||
gppi (sesskey, "BackspaceIsDelete", 1, &cfg.bksp_is_delete);
|
||||
gppi (sesskey, "RXVTHomeEnd", 0, &cfg.rxvt_homeend);
|
||||
@ -995,6 +997,9 @@ static int CALLBACK TelnetProc (HWND hwnd, UINT msg,
|
||||
|
||||
static int CALLBACK SshProc (HWND hwnd, UINT msg,
|
||||
WPARAM wParam, LPARAM lParam) {
|
||||
OPENFILENAME of;
|
||||
char filename[sizeof(cfg.keyfile)];
|
||||
|
||||
switch (msg) {
|
||||
case WM_INITDIALOG:
|
||||
SetDlgItemText (hwnd, IDC3_TTEDIT, cfg.termtype);
|
||||
@ -1006,6 +1011,7 @@ static int CALLBACK SshProc (HWND hwnd, UINT msg,
|
||||
|
||||
IDC3_CIPHER3DES);
|
||||
CheckDlgButton (hwnd, IDC3_AUTHTIS, cfg.try_tis_auth);
|
||||
SetDlgItemText (hwnd, IDC3_PKEDIT, cfg.keyfile);
|
||||
break;
|
||||
case WM_COMMAND:
|
||||
switch (LOWORD(wParam)) {
|
||||
@ -1042,6 +1048,36 @@ static int CALLBACK SshProc (HWND hwnd, UINT msg,
|
||||
HIWORD(wParam) == BN_DOUBLECLICKED)
|
||||
cfg.try_tis_auth = IsDlgButtonChecked (hwnd, IDC3_AUTHTIS);
|
||||
break;
|
||||
case IDC3_PKEDIT:
|
||||
if (HIWORD(wParam) == EN_CHANGE)
|
||||
GetDlgItemText (hwnd, IDC3_PKEDIT, cfg.keyfile,
|
||||
sizeof(cfg.keyfile)-1);
|
||||
break;
|
||||
case IDC3_PKBUTTON:
|
||||
/*
|
||||
* FIXME: this crashes. Find out why.
|
||||
*/
|
||||
memset(&of, 0, sizeof(of));
|
||||
#ifdef OPENFILENAME_SIZE_VERSION_400
|
||||
of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
|
||||
#else
|
||||
of.lStructSize = sizeof(of);
|
||||
#endif
|
||||
of.hwndOwner = hwnd;
|
||||
of.lpstrFilter = "All Files\0*\0\0\0";
|
||||
of.lpstrCustomFilter = NULL;
|
||||
of.nFilterIndex = 1;
|
||||
of.lpstrFile = filename; strcpy(filename, cfg.keyfile);
|
||||
of.nMaxFile = sizeof(filename);
|
||||
of.lpstrFileTitle = NULL;
|
||||
of.lpstrInitialDir = NULL;
|
||||
of.lpstrTitle = "Select Public Key File";
|
||||
of.Flags = 0;
|
||||
if (GetOpenFileName(&of)) {
|
||||
strcpy(cfg.keyfile, filename);
|
||||
SetDlgItemText (hwnd, IDC3_PKEDIT, cfg.keyfile);
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user