int smb_tree_disconnect(smb_session *s, smb_tid tid)
{
smb_tree_disconnect_req req;
smb_tree_disconnect_resp *resp;
smb_message *req_msg;
smb_message resp_msg;
assert(s != NULL);
if( s != NULL) {
req_msg = smb_message_new(SMB_CMD_TREE_DISCONNECT);
if (!req_msg)
return DSM_ERROR_GENERIC;
// Packet headers
req_msg->packet->header.tid = (uint16_t)tid;
// Packet payload
req.wct = 0; // Must be 0
req.bct = 0; // Must be 0
SMB_MSG_PUT_PKT(req_msg, req);
if (!smb_session_send_msg(s, req_msg))
{
smb_message_destroy(req_msg);
return DSM_ERROR_NETWORK;
}
smb_message_destroy(req_msg);
if (!smb_session_recv_msg(s, &resp_msg))
return DSM_ERROR_NETWORK;
if (!smb_session_check_nt_status(s, &resp_msg))
return DSM_ERROR_NT;
resp = (smb_tree_disconnect_resp *)resp_msg.packet->payload;
if ((resp->wct != 0) || (resp->bct != 0))
return DSM_ERROR_NETWORK;
return DSM_SUCCESS;
}
return DSM_ERROR_GENERIC;
}
static int auth(smb_session *s, const char *domain, const char *user,
const char *password)
{
smb_message *msg = NULL, resp;
smb_session_xsec_req req;
smb_buffer ntlm;
ASN1_TYPE token;
int res, der_size = 512;
char der[512], err_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
msg = smb_message_new(SMB_CMD_SETUP);
if (!msg)
return DSM_ERROR_GENERIC;
// this struct will be set at the end when we know the payload size
SMB_MSG_ADVANCE_PKT(msg, smb_session_xsec_req);
asn1_create_element(s->spnego_asn1, "SPNEGO.NegotiationToken", &token);
// Select a response message type
res = asn1_write_value(token, "", "negTokenResp", 1);
if (res != ASN1_SUCCESS) goto error;
// Delete all optionnal field except 'ResponseToken'
res = asn1_write_value(token, "negTokenResp.negResult", NULL, 0);
if (res != ASN1_SUCCESS) goto error;
res = asn1_write_value(token, "negTokenResp.supportedMech", NULL, 0);
if (res != ASN1_SUCCESS) goto error;
res = asn1_write_value(token, "negTokenResp.mechListMIC", NULL, 0);
if (res != ASN1_SUCCESS) goto error;
smb_ntlmssp_response(s->srv.challenge, s->srv.ts - 4200, domain, domain, user,
password, &s->xsec_target, &ntlm);
res = asn1_write_value(token, "negTokenResp.responseToken", ntlm.data,
ntlm.size);
smb_buffer_free(&ntlm);
if (res != ASN1_SUCCESS) goto error;
res = asn1_der_coding(token, "", der, &der_size, err_desc);
if (res != ASN1_SUCCESS)
{
smb_message_destroy(msg);
BDSM_dbg("Encoding error: %s", err_desc);
return DSM_ERROR_GENERIC;
}
smb_message_append(msg, der, der_size);
if (msg->cursor % 2)
smb_message_put8(msg, 0);
smb_message_put_utf16(msg, SMB_OS, strlen(SMB_OS));
smb_message_put16(msg, 0);
smb_message_put_utf16(msg, SMB_LANMAN, strlen(SMB_LANMAN));
smb_message_put16(msg, 0);
smb_message_put16(msg, 0); // Empty PDC name
SMB_MSG_INIT_PKT_ANDX(req);
req.wct = 12;
req.max_buffer = SMB_SESSION_MAX_BUFFER;
req.mpx_count = 16; // XXX ?
req.vc_count = 1;
req.caps = s->srv.caps; // XXX caps & our_caps_mask
req.session_key = s->srv.session_key;
req.xsec_blob_size = der_size;
req.payload_size = msg->cursor - sizeof(smb_session_xsec_req);
SMB_MSG_INSERT_PKT(msg, 0, req);
asn1_delete_structure(&token);
if (!smb_session_send_msg(s, msg))
{
smb_message_destroy(msg);
BDSM_dbg("Unable to send Session Setup AndX (NTLMSSP_AUTH) message\n");
return DSM_ERROR_NETWORK;
}
smb_message_destroy(msg);
if (smb_session_recv_msg(s, &resp) == 0)
return DSM_ERROR_NETWORK;
if (!smb_session_check_nt_status(s, &resp))
return DSM_ERROR_NT;
else
{
smb_session_xsec_resp *r = (smb_session_xsec_resp *)resp.packet->payload;
if (r->action & 0x0001)
s->guest = true;
s->srv.uid = resp.packet->header.uid;
s->logged = true;
return DSM_SUCCESS;
}
error:
asn1_display_error("smb_session_login auth()", res);
smb_message_destroy(msg);
return DSM_ERROR_GENERIC;
}
int smb_tree_connect(smb_session *s, const char *name, smb_tid *tid)
{
smb_tree_connect_req req;
smb_tree_connect_resp *resp;
smb_message resp_msg;
smb_message *req_msg;
smb_share *share;
size_t path_len, utf_path_len;
char *path, *utf_path;
assert(s != NULL && name != NULL && tid != NULL);
if( s != NULL && name != NULL && tid != NULL ) {
req_msg = smb_message_new(SMB_CMD_TREE_CONNECT);
if (!req_msg)
return DSM_ERROR_GENERIC;
// Build \\SERVER\Share path from name
path_len = strlen(name) + strlen(s->srv.name) + 4;
path = alloca(path_len);
snprintf(path, path_len, "\\\\%s\\%s", s->srv.name, name);
utf_path_len = smb_to_utf16(path, strlen(path) + 1, &utf_path);
// Packet headers
req_msg->packet->header.tid = 0xffff; // Behavior of libsmbclient
smb_message_set_andx_members(req_msg);
// Packet payload
SMB_MSG_INIT_PKT_ANDX(req);
req.wct = 4;
req.flags = 0x0c; // (??)
req.passwd_len = 1; // Null byte
req.bct = utf_path_len + 6 + 1;
SMB_MSG_PUT_PKT(req_msg, req);
smb_message_put8(req_msg, 0); // Ze null byte password;
smb_message_append(req_msg, utf_path, utf_path_len);
free(utf_path);
smb_message_append(req_msg, "?????", strlen("?????") + 1);
if (!smb_session_send_msg(s, req_msg))
{
smb_message_destroy(req_msg);
return DSM_ERROR_NETWORK;
}
smb_message_destroy(req_msg);
if (!smb_session_recv_msg(s, &resp_msg))
return DSM_ERROR_NETWORK;
if (!smb_session_check_nt_status(s, &resp_msg))
return DSM_ERROR_NT;
resp = (smb_tree_connect_resp *)resp_msg.packet->payload;
share = calloc(1, sizeof(smb_share));
if (!share)
return DSM_ERROR_GENERIC;
share->tid = resp_msg.packet->header.tid;
share->opts = resp->opt_support;
share->rights = resp->max_rights;
share->guest_rights = resp->guest_rights;
smb_session_share_add(s, share);
*tid = share->tid;
return 0;
}
return DSM_ERROR_GENERIC;
}
