version 1.6.2.3, 2000/11/08 21:30:51 |
version 1.6.2.4, 2001/03/12 15:44:11 |
|
|
#include "includes.h" |
#include "includes.h" |
RCSID("$OpenBSD$"); |
RCSID("$OpenBSD$"); |
|
|
#include "ssh.h" |
|
#include "ssh2.h" |
|
#include "xmalloc.h" |
|
#include "buffer.h" |
|
#include "bufaux.h" |
|
#include "packet.h" |
|
#include "compat.h" |
|
|
|
#include <openssl/bn.h> |
|
#include <openssl/dh.h> |
|
|
|
#include <openssl/crypto.h> |
#include <openssl/crypto.h> |
#include <openssl/bio.h> |
#include <openssl/bio.h> |
#include <openssl/bn.h> |
#include <openssl/bn.h> |
#include <openssl/dh.h> |
#include <openssl/dh.h> |
#include <openssl/pem.h> |
#include <openssl/pem.h> |
|
|
|
#include "ssh2.h" |
|
#include "xmalloc.h" |
|
#include "buffer.h" |
|
#include "bufaux.h" |
|
#include "packet.h" |
|
#include "compat.h" |
|
#include "cipher.h" |
#include "kex.h" |
#include "kex.h" |
|
#include "key.h" |
|
#include "log.h" |
|
#include "mac.h" |
|
|
#define KEX_COOKIE_LEN 16 |
#define KEX_COOKIE_LEN 16 |
|
|
|
|
kex_init(char *myproposal[PROPOSAL_MAX]) |
kex_init(char *myproposal[PROPOSAL_MAX]) |
{ |
{ |
int first_kex_packet_follows = 0; |
int first_kex_packet_follows = 0; |
unsigned char cookie[KEX_COOKIE_LEN]; |
u_char cookie[KEX_COOKIE_LEN]; |
u_int32_t rand = 0; |
u_int32_t rand = 0; |
int i; |
int i; |
Buffer *ki = xmalloc(sizeof(*ki)); |
Buffer *ki = xmalloc(sizeof(*ki)); |
|
|
|
|
debug("send KEXINIT"); |
debug("send KEXINIT"); |
packet_start(SSH2_MSG_KEXINIT); |
packet_start(SSH2_MSG_KEXINIT); |
packet_put_raw(buffer_ptr(my_kexinit), buffer_len(my_kexinit)); |
packet_put_raw(buffer_ptr(my_kexinit), buffer_len(my_kexinit)); |
packet_send(); |
packet_send(); |
packet_write_wait(); |
packet_write_wait(); |
debug("done"); |
debug("done"); |
|
|
return 0; |
return 0; |
} |
} |
|
|
DH * |
void |
dh_gen_key(DH *dh) |
dh_gen_key(DH *dh) |
{ |
{ |
int tries = 0; |
int tries = 0; |
|
|
if (tries++ > 10) |
if (tries++ > 10) |
fatal("dh_new_group1: too many bad keys: giving up"); |
fatal("dh_new_group1: too many bad keys: giving up"); |
} while (!dh_pub_is_valid(dh, dh->pub_key)); |
} while (!dh_pub_is_valid(dh, dh->pub_key)); |
return dh; |
|
} |
} |
|
|
DH * |
DH * |
|
|
if ((ret = BN_hex2bn(&dh->g, gen)) < 0) |
if ((ret = BN_hex2bn(&dh->g, gen)) < 0) |
fatal("BN_hex2bn g"); |
fatal("BN_hex2bn g"); |
|
|
return (dh_gen_key(dh)); |
return (dh); |
} |
} |
|
|
|
/* |
|
* This just returns the group, we still need to generate the exchange |
|
* value. |
|
*/ |
|
|
DH * |
DH * |
dh_new_group(BIGNUM *gen, BIGNUM *modulus) |
dh_new_group(BIGNUM *gen, BIGNUM *modulus) |
{ |
{ |
|
|
dh->p = modulus; |
dh->p = modulus; |
dh->g = gen; |
dh->g = gen; |
|
|
return (dh_gen_key(dh)); |
return (dh); |
} |
} |
|
|
DH * |
DH * |
dh_new_group1() |
dh_new_group1(void) |
{ |
{ |
static char *gen = "2", *group1 = |
static char *gen = "2", *group1 = |
"FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1" |
"FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1" |
|
|
return (dh_new_group_asc(gen, group1)); |
return (dh_new_group_asc(gen, group1)); |
} |
} |
|
|
|
#ifdef DEBUG_KEX |
void |
void |
dump_digest(unsigned char *digest, int len) |
dump_digest(u_char *digest, int len) |
{ |
{ |
int i; |
int i; |
for (i = 0; i< len; i++){ |
for (i = 0; i< len; i++){ |
|
|
} |
} |
fprintf(stderr, "\n"); |
fprintf(stderr, "\n"); |
} |
} |
|
#endif |
|
|
unsigned char * |
u_char * |
kex_hash( |
kex_hash( |
char *client_version_string, |
char *client_version_string, |
char *server_version_string, |
char *server_version_string, |
|
|
BIGNUM *shared_secret) |
BIGNUM *shared_secret) |
{ |
{ |
Buffer b; |
Buffer b; |
static unsigned char digest[EVP_MAX_MD_SIZE]; |
static u_char digest[EVP_MAX_MD_SIZE]; |
EVP_MD *evp_md = EVP_sha1(); |
EVP_MD *evp_md = EVP_sha1(); |
EVP_MD_CTX md; |
EVP_MD_CTX md; |
|
|
|
|
buffer_put_bignum2(&b, client_dh_pub); |
buffer_put_bignum2(&b, client_dh_pub); |
buffer_put_bignum2(&b, server_dh_pub); |
buffer_put_bignum2(&b, server_dh_pub); |
buffer_put_bignum2(&b, shared_secret); |
buffer_put_bignum2(&b, shared_secret); |
|
|
#ifdef DEBUG_KEX |
#ifdef DEBUG_KEX |
buffer_dump(&b); |
buffer_dump(&b); |
#endif |
#endif |
|
|
return digest; |
return digest; |
} |
} |
|
|
unsigned char * |
u_char * |
kex_hash_gex( |
kex_hash_gex( |
char *client_version_string, |
char *client_version_string, |
char *server_version_string, |
char *server_version_string, |
|
|
BIGNUM *shared_secret) |
BIGNUM *shared_secret) |
{ |
{ |
Buffer b; |
Buffer b; |
static unsigned char digest[EVP_MAX_MD_SIZE]; |
static u_char digest[EVP_MAX_MD_SIZE]; |
EVP_MD *evp_md = EVP_sha1(); |
EVP_MD *evp_md = EVP_sha1(); |
EVP_MD_CTX md; |
EVP_MD_CTX md; |
|
|
|
|
buffer_put_bignum2(&b, client_dh_pub); |
buffer_put_bignum2(&b, client_dh_pub); |
buffer_put_bignum2(&b, server_dh_pub); |
buffer_put_bignum2(&b, server_dh_pub); |
buffer_put_bignum2(&b, shared_secret); |
buffer_put_bignum2(&b, shared_secret); |
|
|
#ifdef DEBUG_KEX |
#ifdef DEBUG_KEX |
buffer_dump(&b); |
buffer_dump(&b); |
#endif |
#endif |
|
|
return digest; |
return digest; |
} |
} |
|
|
unsigned char * |
u_char * |
derive_key(int id, int need, char unsigned *hash, BIGNUM *shared_secret) |
derive_key(int id, int need, u_char *hash, BIGNUM *shared_secret) |
{ |
{ |
Buffer b; |
Buffer b; |
EVP_MD *evp_md = EVP_sha1(); |
EVP_MD *evp_md = EVP_sha1(); |
|
|
char c = id; |
char c = id; |
int have; |
int have; |
int mdsz = evp_md->md_size; |
int mdsz = evp_md->md_size; |
unsigned char *digest = xmalloc(((need+mdsz-1)/mdsz)*mdsz); |
u_char *digest = xmalloc(((need+mdsz-1)/mdsz)*mdsz); |
|
|
buffer_init(&b); |
buffer_init(&b); |
buffer_put_bignum2(&b, shared_secret); |
buffer_put_bignum2(&b, shared_secret); |
|
|
c = cp = xstrdup(client); |
c = cp = xstrdup(client); |
s = sp = xstrdup(server); |
s = sp = xstrdup(server); |
|
|
for ((p = strsep(&sp, SEP)), i=0; p && *p != '\0'; |
for ((p = strsep(&sp, SEP)), i=0; p && *p != '\0'; |
(p = strsep(&sp, SEP)), i++) { |
(p = strsep(&sp, SEP)), i++) { |
if (i < MAX_PROP) |
if (i < MAX_PROP) |
sproposals[i] = p; |
sproposals[i] = p; |
|
|
} |
} |
nproposals = i; |
nproposals = i; |
|
|
for ((p = strsep(&cp, SEP)), i=0; p && *p != '\0'; |
for ((p = strsep(&cp, SEP)), i=0; p && *p != '\0'; |
(p = strsep(&cp, SEP)), i++) { |
(p = strsep(&cp, SEP)), i++) { |
for (j = 0; j < nproposals; j++) { |
for (j = 0; j < nproposals; j++) { |
if (strcmp(p, sproposals[j]) == 0) { |
if (strcmp(p, sproposals[j]) == 0) { |
|
|
char *name = get_match(client, server); |
char *name = get_match(client, server); |
if (name == NULL) |
if (name == NULL) |
fatal("no matching mac found: client %s server %s", client, server); |
fatal("no matching mac found: client %s server %s", client, server); |
if (strcmp(name, "hmac-md5") == 0) { |
if (mac_init(mac, name) < 0) |
mac->md = EVP_md5(); |
|
} else if (strcmp(name, "hmac-sha1") == 0) { |
|
mac->md = EVP_sha1(); |
|
} else if (strcmp(name, "hmac-ripemd160@openssh.com") == 0) { |
|
mac->md = EVP_ripemd160(); |
|
} else { |
|
fatal("unsupported mac %s", name); |
fatal("unsupported mac %s", name); |
} |
/* truncate the key */ |
|
if (datafellows & SSH_BUG_HMAC) |
|
mac->key_len = 16; |
mac->name = name; |
mac->name = name; |
mac->mac_len = mac->md->md_size; |
|
mac->key_len = (datafellows & SSH_BUG_HMAC) ? 16 : mac->mac_len; |
|
mac->key = NULL; |
mac->key = NULL; |
mac->enabled = 0; |
mac->enabled = 0; |
} |
} |
|
|
void |
void |
choose_hostkeyalg(Kex *k, char *client, char *server) |
choose_hostkeyalg(Kex *k, char *client, char *server) |
{ |
{ |
k->hostkeyalg = get_match(client, server); |
char *hostkeyalg = get_match(client, server); |
if (k->hostkeyalg == NULL) |
if (hostkeyalg == NULL) |
fatal("no hostkey alg"); |
fatal("no hostkey alg"); |
if (strcmp(k->hostkeyalg, KEX_DSS) != 0) |
k->hostkey_type = key_type_from_name(hostkeyalg); |
fatal("bad hostkey alg %s", k->hostkeyalg); |
if (k->hostkey_type == KEY_UNSPEC) |
|
fatal("bad hostkey alg '%s'", hostkeyalg); |
|
xfree(hostkeyalg); |
} |
} |
|
|
Kex * |
Kex * |
|
|
} |
} |
|
|
int |
int |
kex_derive_keys(Kex *k, unsigned char *hash, BIGNUM *shared_secret) |
kex_derive_keys(Kex *k, u_char *hash, BIGNUM *shared_secret) |
{ |
{ |
int i; |
int i; |
int mode; |
int mode; |
int ctos; |
int ctos; |
unsigned char *keys[NKEYS]; |
u_char *keys[NKEYS]; |
|
|
for (i = 0; i < NKEYS; i++) |
for (i = 0; i < NKEYS; i++) |
keys[i] = derive_key('A'+i, k->we_need, hash, shared_secret); |
keys[i] = derive_key('A'+i, k->we_need, hash, shared_secret); |