#include "includes.h"
struct outstanding_packet_lookup {
struct outstanding_packet_lookup *prev, *next;
uint16 mid;
uint32 reply_seq_num;
};
struct smb_basic_signing_context {
DATA_BLOB mac_key;
uint32 send_seq_num;
struct outstanding_packet_lookup *outstanding_packet_list;
};
static BOOL store_sequence_for_reply(struct outstanding_packet_lookup **list,
uint16 mid, uint32 reply_seq_num)
{
struct outstanding_packet_lookup *t;
for (t = *list; t; t = t->next) {
if (t->mid == mid) {
DLIST_REMOVE(*list, t);
SAFE_FREE(t);
break;
}
}
t = SMB_XMALLOC_P(struct outstanding_packet_lookup);
ZERO_STRUCTP(t);
t->mid = mid;
t->reply_seq_num = reply_seq_num;
DLIST_ADD(*list, t);
DEBUG(10,("store_sequence_for_reply: stored seq = %u mid = %u\n",
(unsigned int)reply_seq_num, (unsigned int)mid ));
return True;
}
static BOOL get_sequence_for_reply(struct outstanding_packet_lookup **list,
uint16 mid, uint32 *reply_seq_num)
{
struct outstanding_packet_lookup *t;
for (t = *list; t; t = t->next) {
if (t->mid == mid) {
*reply_seq_num = t->reply_seq_num;
DEBUG(10,("get_sequence_for_reply: found seq = %u mid = %u\n",
(unsigned int)t->reply_seq_num, (unsigned int)t->mid ));
DLIST_REMOVE(*list, t);
SAFE_FREE(t);
return True;
}
}
return False;
}
static BOOL cli_set_smb_signing_common(struct cli_state *cli)
{
if (!cli->sign_info.allow_smb_signing) {
return False;
}
if (!cli->sign_info.negotiated_smb_signing
&& !cli->sign_info.mandatory_signing) {
return False;
}
if (cli->sign_info.doing_signing) {
return False;
}
if (cli->sign_info.free_signing_context)
cli->sign_info.free_signing_context(&cli->sign_info);
cli->readbraw_supported = False;
cli->writebraw_supported = False;
return True;
}
static BOOL set_smb_signing_real_common(struct smb_sign_info *si)
{
if (si->mandatory_signing) {
DEBUG(5, ("Mandatory SMB signing enabled!\n"));
}
si->doing_signing = True;
DEBUG(5, ("SMB signing enabled!\n"));
return True;
}
static void mark_packet_signed(char *outbuf)
{
uint16 flags2;
flags2 = SVAL(outbuf,smb_flg2);
flags2 |= FLAGS2_SMB_SECURITY_SIGNATURES;
SSVAL(outbuf,smb_flg2, flags2);
}
static void null_sign_outgoing_message(char *outbuf, struct smb_sign_info *si)
{
return;
}
static BOOL null_check_incoming_message(char *inbuf, struct smb_sign_info *si, BOOL must_be_ok)
{
return True;
}
static void null_free_signing_context(struct smb_sign_info *si)
{
return;
}
static BOOL null_set_signing(struct smb_sign_info *si)
{
si->signing_context = NULL;
si->sign_outgoing_message = null_sign_outgoing_message;
si->check_incoming_message = null_check_incoming_message;
si->free_signing_context = null_free_signing_context;
return True;
}
static void free_signing_context(struct smb_sign_info *si)
{
if (si->free_signing_context) {
si->free_signing_context(si);
si->signing_context = NULL;
}
null_set_signing(si);
}
static BOOL signing_good(char *inbuf, struct smb_sign_info *si, BOOL good, uint32 seq, BOOL must_be_ok)
{
if (good) {
if (!si->doing_signing) {
si->doing_signing = True;
}
if (!si->seen_valid) {
si->seen_valid = True;
}
} else {
if (!si->mandatory_signing && !si->seen_valid) {
if (!must_be_ok) {
return True;
}
DEBUG(5, ("srv_check_incoming_message: signing negotiated but not required and peer\n"
"isn't sending correct signatures. Turning off.\n"));
si->negotiated_smb_signing = False;
si->allow_smb_signing = False;
si->doing_signing = False;
free_signing_context(si);
return True;
} else if (!must_be_ok) {
return True;
} else {
if (seq)
DEBUG(0, ("signing_good: BAD SIG: seq %u\n", (unsigned int)seq));
return False;
}
}
return True;
}
static void simple_packet_signature(struct smb_basic_signing_context *data,
const uchar *buf, uint32 seq_number,
unsigned char calc_md5_mac[16])
{
const size_t offset_end_of_sig = (smb_ss_field + 8);
unsigned char sequence_buf[8];
struct MD5Context md5_ctx;
#if 0
unsigned char key_buf[16];
#endif
DEBUG(10,("simple_packet_signature: sequence number %u\n", seq_number ));
SIVAL(sequence_buf, 0, seq_number);
SIVAL(sequence_buf, 4, 0);
MD5Init(&md5_ctx);
MD5Update(&md5_ctx, data->mac_key.data, data->mac_key.length);
#if 0
if (data->mac_key.length < sizeof(key_buf)) {
memset(key_buf, 0, sizeof(key_buf));
MD5Update(&md5_ctx, key_buf, sizeof(key_buf) - data->mac_key.length);
}
#endif
MD5Update(&md5_ctx, buf + 4, smb_ss_field - 4);
MD5Update(&md5_ctx, sequence_buf, sizeof(sequence_buf));
MD5Update(&md5_ctx, buf + offset_end_of_sig,
smb_len(buf) - (offset_end_of_sig - 4));
MD5Final(calc_md5_mac, &md5_ctx);
}
static void client_sign_outgoing_message(char *outbuf, struct smb_sign_info *si)
{
unsigned char calc_md5_mac[16];
struct smb_basic_signing_context *data =
(struct smb_basic_signing_context *)si->signing_context;
if (!si->doing_signing)
return;
if (smb_len(outbuf) < (smb_ss_field + 8 - 4)) {
DEBUG(1, ("client_sign_outgoing_message: Logic error. Can't check signature on short packet! smb_len = %u\n",
smb_len(outbuf) ));
abort();
}
mark_packet_signed(outbuf);
simple_packet_signature(data, (const unsigned char *)outbuf,
data->send_seq_num, calc_md5_mac);
DEBUG(10, ("client_sign_outgoing_message: sent SMB signature of\n"));
dump_data(10, (const char *)calc_md5_mac, 8);
memcpy(&outbuf[smb_ss_field], calc_md5_mac, 8);
if (store_sequence_for_reply(&data->outstanding_packet_list, SVAL(outbuf,smb_mid), data->send_seq_num + 1)) {
data->send_seq_num += 2;
}
}
static BOOL client_check_incoming_message(char *inbuf, struct smb_sign_info *si, BOOL must_be_ok)
{
BOOL good;
uint32 reply_seq_number;
unsigned char calc_md5_mac[16];
unsigned char *server_sent_mac;
struct smb_basic_signing_context *data =
(struct smb_basic_signing_context *)si->signing_context;
if (!si->doing_signing)
return True;
if (smb_len(inbuf) < (smb_ss_field + 8 - 4)) {
DEBUG(1, ("client_check_incoming_message: Can't check signature on short packet! smb_len = %u\n", smb_len(inbuf)));
return False;
}
if (!get_sequence_for_reply(&data->outstanding_packet_list, SVAL(inbuf, smb_mid), &reply_seq_number)) {
DEBUG(1, ("client_check_incoming_message: received message "
"with mid %u with no matching send record.\n", (unsigned int)SVAL(inbuf, smb_mid) ));
return False;
}
simple_packet_signature(data, (const unsigned char *)inbuf,
reply_seq_number, calc_md5_mac);
server_sent_mac = (unsigned char *)&inbuf[smb_ss_field];
good = (memcmp(server_sent_mac, calc_md5_mac, 8) == 0);
if (!good) {
DEBUG(5, ("client_check_incoming_message: BAD SIG: wanted SMB signature of\n"));
dump_data(5, (const char *)calc_md5_mac, 8);
DEBUG(5, ("client_check_incoming_message: BAD SIG: got SMB signature of\n"));
dump_data(5, (const char *)server_sent_mac, 8);
#if 1
{
int i;
for (i = -5; i < 5; i++) {
simple_packet_signature(data, (const unsigned char *)inbuf, reply_seq_number+i, calc_md5_mac);
if (memcmp(server_sent_mac, calc_md5_mac, 8) == 0) {
DEBUG(0,("client_check_incoming_message: out of seq. seq num %u matches. \
We were expecting seq %u\n", reply_seq_number+i, reply_seq_number ));
break;
}
}
}
#endif
} else {
DEBUG(10, ("client_check_incoming_message: seq %u: got good SMB signature of\n", (unsigned int)reply_seq_number));
dump_data(10, (const char *)server_sent_mac, 8);
}
return signing_good(inbuf, si, good, reply_seq_number, must_be_ok);
}
static void simple_free_signing_context(struct smb_sign_info *si)
{
struct smb_basic_signing_context *data =
(struct smb_basic_signing_context *)si->signing_context;
struct outstanding_packet_lookup *list;
struct outstanding_packet_lookup *next;
for (list = data->outstanding_packet_list; list; list = next) {
next = list->next;
DLIST_REMOVE(data->outstanding_packet_list, list);
SAFE_FREE(list);
}
data_blob_free(&data->mac_key);
SAFE_FREE(si->signing_context);
return;
}
BOOL cli_simple_set_signing(struct cli_state *cli,
const DATA_BLOB user_session_key,
const DATA_BLOB response)
{
struct smb_basic_signing_context *data;
if (!user_session_key.length)
return False;
if (!cli_set_smb_signing_common(cli)) {
return False;
}
if (!set_smb_signing_real_common(&cli->sign_info)) {
return False;
}
data = SMB_XMALLOC_P(struct smb_basic_signing_context);
memset(data, '\0', sizeof(*data));
cli->sign_info.signing_context = data;
data->mac_key = data_blob(NULL, response.length + user_session_key.length);
memcpy(&data->mac_key.data[0], user_session_key.data, user_session_key.length);
DEBUG(10, ("cli_simple_set_signing: user_session_key\n"));
dump_data(10, (const char *)user_session_key.data, user_session_key.length);
if (response.length) {
memcpy(&data->mac_key.data[user_session_key.length],response.data, response.length);
DEBUG(10, ("cli_simple_set_signing: response_data\n"));
dump_data(10, (const char *)response.data, response.length);
} else {
DEBUG(10, ("cli_simple_set_signing: NULL response_data\n"));
}
dump_data_pw("MAC ssession key is:\n", data->mac_key.data, data->mac_key.length);
data->send_seq_num = 0;
data->outstanding_packet_list = NULL;
cli->sign_info.sign_outgoing_message = client_sign_outgoing_message;
cli->sign_info.check_incoming_message = client_check_incoming_message;
cli->sign_info.free_signing_context = simple_free_signing_context;
return True;
}
static void temp_sign_outgoing_message(char *outbuf, struct smb_sign_info *si)
{
mark_packet_signed(outbuf);
memcpy(&outbuf[smb_ss_field], "BSRSPYL ", 8);
return;
}
static BOOL temp_check_incoming_message(char *inbuf, struct smb_sign_info *si, BOOL foo)
{
return True;
}
static void temp_free_signing_context(struct smb_sign_info *si)
{
return;
}
BOOL cli_null_set_signing(struct cli_state *cli)
{
return null_set_signing(&cli->sign_info);
}
BOOL cli_temp_set_signing(struct cli_state *cli)
{
if (!cli_set_smb_signing_common(cli)) {
return False;
}
cli->sign_info.signing_context = NULL;
cli->sign_info.sign_outgoing_message = temp_sign_outgoing_message;
cli->sign_info.check_incoming_message = temp_check_incoming_message;
cli->sign_info.free_signing_context = temp_free_signing_context;
return True;
}
void cli_free_signing_context(struct cli_state *cli)
{
free_signing_context(&cli->sign_info);
}
void cli_calculate_sign_mac(struct cli_state *cli)
{
cli->sign_info.sign_outgoing_message(cli->outbuf, &cli->sign_info);
}
BOOL cli_check_sign_mac(struct cli_state *cli)
{
if (!cli->sign_info.check_incoming_message(cli->inbuf, &cli->sign_info, True)) {
free_signing_context(&cli->sign_info);
return False;
}
return True;
}
static void srv_sign_outgoing_message(char *outbuf, struct smb_sign_info *si)
{
unsigned char calc_md5_mac[16];
struct smb_basic_signing_context *data =
(struct smb_basic_signing_context *)si->signing_context;
uint32 send_seq_number = data->send_seq_num-1;
uint16 mid;
if (!si->doing_signing) {
return;
}
if (smb_len(outbuf) < (smb_ss_field + 8 - 4)) {
DEBUG(1, ("srv_sign_outgoing_message: Logic error. Can't send signature on short packet! smb_len = %u\n",
smb_len(outbuf) ));
abort();
}
mark_packet_signed(outbuf);
mid = SVAL(outbuf, smb_mid);
get_sequence_for_reply(&data->outstanding_packet_list, mid, &send_seq_number);
simple_packet_signature(data, (const unsigned char *)outbuf, send_seq_number, calc_md5_mac);
DEBUG(10, ("srv_sign_outgoing_message: seq %u: sent SMB signature of\n", (unsigned int)send_seq_number));
dump_data(10, (const char *)calc_md5_mac, 8);
memcpy(&outbuf[smb_ss_field], calc_md5_mac, 8);
}
static BOOL srv_check_incoming_message(char *inbuf, struct smb_sign_info *si, BOOL must_be_ok)
{
BOOL good;
struct smb_basic_signing_context *data =
(struct smb_basic_signing_context *)si->signing_context;
uint32 reply_seq_number = data->send_seq_num;
uint32 saved_seq;
unsigned char calc_md5_mac[16];
unsigned char *server_sent_mac;
if (!si->doing_signing)
return True;
if (smb_len(inbuf) < (smb_ss_field + 8 - 4)) {
DEBUG(1, ("srv_check_incoming_message: Can't check signature on short packet! smb_len = %u\n", smb_len(inbuf)));
return False;
}
data->send_seq_num += 2;
saved_seq = reply_seq_number;
simple_packet_signature(data, (const unsigned char *)inbuf, reply_seq_number, calc_md5_mac);
server_sent_mac = (unsigned char *)&inbuf[smb_ss_field];
good = (memcmp(server_sent_mac, calc_md5_mac, 8) == 0);
if (!good) {
if (saved_seq) {
DEBUG(0, ("srv_check_incoming_message: BAD SIG: seq %u wanted SMB signature of\n",
(unsigned int)saved_seq));
dump_data(5, (const char *)calc_md5_mac, 8);
DEBUG(0, ("srv_check_incoming_message: BAD SIG: seq %u got SMB signature of\n",
(unsigned int)reply_seq_number));
dump_data(5, (const char *)server_sent_mac, 8);
}
#if 1
{
int i;
reply_seq_number -= 5;
for (i = 0; i < 10; i++, reply_seq_number++) {
simple_packet_signature(data, (const unsigned char *)inbuf, reply_seq_number, calc_md5_mac);
if (memcmp(server_sent_mac, calc_md5_mac, 8) == 0) {
DEBUG(0,("srv_check_incoming_message: out of seq. seq num %u matches. \
We were expecting seq %u\n", reply_seq_number, saved_seq ));
break;
}
}
}
#endif
} else {
DEBUG(10, ("srv_check_incoming_message: seq %u: (current is %u) got good SMB signature of\n", (unsigned int)reply_seq_number, (unsigned int)data->send_seq_num));
dump_data(10, (const char *)server_sent_mac, 8);
}
return (signing_good(inbuf, si, good, saved_seq, must_be_ok));
}
static struct smb_sign_info srv_sign_info = {
null_sign_outgoing_message,
null_check_incoming_message,
null_free_signing_context,
NULL,
False,
False,
False,
False
};
BOOL srv_oplock_set_signing(BOOL onoff)
{
BOOL ret = srv_sign_info.doing_signing;
srv_sign_info.doing_signing = onoff;
return ret;
}
BOOL srv_check_sign_mac(char *inbuf, BOOL must_be_ok)
{
if(CVAL(inbuf,0) == SMBkeepalive)
return True;
return srv_sign_info.check_incoming_message(inbuf, &srv_sign_info, must_be_ok);
}
void srv_calculate_sign_mac(char *outbuf)
{
if(CVAL(outbuf,0) == SMBkeepalive)
return;
srv_sign_info.sign_outgoing_message(outbuf, &srv_sign_info);
}
void srv_defer_sign_response(uint16 mid)
{
struct smb_basic_signing_context *data;
if (!srv_sign_info.doing_signing)
return;
data = (struct smb_basic_signing_context *)srv_sign_info.signing_context;
if (!data)
return;
store_sequence_for_reply(&data->outstanding_packet_list, mid,
data->send_seq_num-1);
}
void srv_cancel_sign_response(uint16 mid)
{
struct smb_basic_signing_context *data;
uint32 dummy_seq;
if (!srv_sign_info.doing_signing)
return;
data = (struct smb_basic_signing_context *)srv_sign_info.signing_context;
if (!data)
return;
DEBUG(10,("srv_cancel_sign_response: for mid %u\n", (unsigned int)mid ));
while (get_sequence_for_reply(&data->outstanding_packet_list, mid, &dummy_seq))
;
data->send_seq_num -= 1;
}
void srv_set_signing_negotiated(void)
{
srv_sign_info.allow_smb_signing = True;
srv_sign_info.negotiated_smb_signing = True;
if (lp_server_signing() == Required)
srv_sign_info.mandatory_signing = True;
srv_sign_info.sign_outgoing_message = temp_sign_outgoing_message;
srv_sign_info.check_incoming_message = temp_check_incoming_message;
srv_sign_info.free_signing_context = temp_free_signing_context;
}
BOOL srv_is_signing_active(void)
{
return srv_sign_info.doing_signing;
}
BOOL srv_is_signing_negotiated(void)
{
return srv_sign_info.negotiated_smb_signing;
}
BOOL srv_signing_started(void)
{
struct smb_basic_signing_context *data;
if (!srv_sign_info.doing_signing) {
return False;
}
data = (struct smb_basic_signing_context *)srv_sign_info.signing_context;
if (!data)
return False;
if (data->send_seq_num == 0) {
return False;
}
return True;
}
void srv_set_signing(const DATA_BLOB user_session_key, const DATA_BLOB response)
{
struct smb_basic_signing_context *data;
if (!user_session_key.length)
return;
if (!srv_sign_info.negotiated_smb_signing && !srv_sign_info.mandatory_signing) {
DEBUG(5,("srv_set_signing: signing negotiated = %u, mandatory_signing = %u. Not allowing smb signing.\n",
(unsigned int)srv_sign_info.negotiated_smb_signing,
(unsigned int)srv_sign_info.mandatory_signing ));
return;
}
if (srv_sign_info.doing_signing) {
return;
}
if (srv_sign_info.free_signing_context)
srv_sign_info.free_signing_context(&srv_sign_info);
srv_sign_info.doing_signing = True;
data = SMB_XMALLOC_P(struct smb_basic_signing_context);
memset(data, '\0', sizeof(*data));
srv_sign_info.signing_context = data;
data->mac_key = data_blob(NULL, response.length + user_session_key.length);
memcpy(&data->mac_key.data[0], user_session_key.data, user_session_key.length);
if (response.length)
memcpy(&data->mac_key.data[user_session_key.length],response.data, response.length);
dump_data_pw("MAC ssession key is:\n", data->mac_key.data, data->mac_key.length);
DEBUG(3,("srv_set_signing: turning on SMB signing: signing negotiated = %s, mandatory_signing = %s.\n",
BOOLSTR(srv_sign_info.negotiated_smb_signing),
BOOLSTR(srv_sign_info.mandatory_signing) ));
data->send_seq_num = 0;
data->outstanding_packet_list = NULL;
srv_sign_info.sign_outgoing_message = srv_sign_outgoing_message;
srv_sign_info.check_incoming_message = srv_check_incoming_message;
srv_sign_info.free_signing_context = simple_free_signing_context;
}