mirror of
https://github.com/samba-team/samba.git
synced 2024-12-22 13:34:15 +03:00
950f0b47d9
Signed-off-by: Andreas Schneider <asn@samba.org> Reviewed-by: Andrew Bartlett <abartlet@samba.org>
868 lines
26 KiB
C
868 lines
26 KiB
C
/*
|
|
Unix SMB/CIFS implementation.
|
|
|
|
Copyright (C) Andrew Tridgell 2005
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/*
|
|
a composite API for making handling a generic async session setup
|
|
*/
|
|
|
|
#include "includes.h"
|
|
#include <tevent.h>
|
|
#include "libcli/raw/libcliraw.h"
|
|
#include "libcli/raw/raw_proto.h"
|
|
#include "libcli/composite/composite.h"
|
|
#include "libcli/smb_composite/smb_composite.h"
|
|
#include "libcli/auth/libcli_auth.h"
|
|
#include "auth/auth.h"
|
|
#include "auth/gensec/gensec.h"
|
|
#include "auth/credentials/credentials.h"
|
|
#include "version.h"
|
|
#include "param/param.h"
|
|
#include "libcli/smb/smbXcli_base.h"
|
|
|
|
struct sesssetup_state {
|
|
struct smbcli_session *session;
|
|
union smb_sesssetup setup;
|
|
const char *chosen_oid;
|
|
NTSTATUS remote_status;
|
|
NTSTATUS gensec_status;
|
|
struct smb_composite_sesssetup *io;
|
|
struct smbcli_request *req;
|
|
struct smbcli_request *check_req;
|
|
unsigned int logon_retries;
|
|
};
|
|
|
|
static int sesssetup_state_destructor(struct sesssetup_state *state)
|
|
{
|
|
if (state->req) {
|
|
talloc_free(state->req);
|
|
state->req = NULL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static NTSTATUS session_setup_old(struct composite_context *c,
|
|
struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io,
|
|
struct smbcli_request **req);
|
|
static NTSTATUS session_setup_nt1(struct composite_context *c,
|
|
struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io,
|
|
struct smbcli_request **req);
|
|
static NTSTATUS session_setup_spnego_restart(struct composite_context *c,
|
|
struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io);
|
|
static NTSTATUS session_setup_spnego(struct composite_context *c,
|
|
struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io,
|
|
struct smbcli_request **req);
|
|
static void smb_composite_sesssetup_spnego_done1(struct tevent_req *subreq);
|
|
static void smb_composite_sesssetup_spnego_done2(struct tevent_req *subreq);
|
|
|
|
|
|
/*
|
|
handler for completion of a smbcli_request sub-request
|
|
*/
|
|
static void request_handler(struct smbcli_request *req)
|
|
{
|
|
struct composite_context *c = (struct composite_context *)req->async.private_data;
|
|
struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
|
|
struct smbcli_session *session = req->session;
|
|
DATA_BLOB null_data_blob = data_blob(NULL, 0);
|
|
NTSTATUS session_key_err, nt_status;
|
|
struct smbcli_request *check_req = NULL;
|
|
const char *os = NULL;
|
|
const char *lanman = NULL;
|
|
|
|
if (req->sign_caller_checks) {
|
|
req->do_not_free = true;
|
|
check_req = req;
|
|
}
|
|
|
|
state->remote_status = smb_raw_sesssetup_recv(req, state, &state->setup);
|
|
c->status = state->remote_status;
|
|
state->req = NULL;
|
|
|
|
/*
|
|
* we only need to check the signature if the
|
|
* NT_STATUS_OK is returned
|
|
*/
|
|
if (!NT_STATUS_IS_OK(state->remote_status)) {
|
|
talloc_free(check_req);
|
|
check_req = NULL;
|
|
}
|
|
|
|
switch (state->setup.old.level) {
|
|
case RAW_SESSSETUP_OLD:
|
|
state->io->out.vuid = state->setup.old.out.vuid;
|
|
/* This doesn't work, as this only happens on old
|
|
* protocols, where this comparison won't match. */
|
|
if (NT_STATUS_EQUAL(c->status, NT_STATUS_LOGON_FAILURE)) {
|
|
/* we need to reset the vuid for a new try */
|
|
session->vuid = 0;
|
|
if (cli_credentials_wrong_password(state->io->in.credentials)) {
|
|
nt_status = session_setup_old(c, session,
|
|
state->io,
|
|
&state->req);
|
|
if (NT_STATUS_IS_OK(nt_status)) {
|
|
talloc_free(check_req);
|
|
c->status = nt_status;
|
|
composite_continue_smb(c, state->req, request_handler, c);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (!NT_STATUS_IS_OK(c->status)) {
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
os = state->setup.old.out.os;
|
|
lanman = state->setup.old.out.lanman;
|
|
break;
|
|
|
|
case RAW_SESSSETUP_NT1:
|
|
state->io->out.vuid = state->setup.nt1.out.vuid;
|
|
if (NT_STATUS_EQUAL(c->status, NT_STATUS_LOGON_FAILURE)) {
|
|
/* we need to reset the vuid for a new try */
|
|
session->vuid = 0;
|
|
if (cli_credentials_wrong_password(state->io->in.credentials)) {
|
|
nt_status = session_setup_nt1(c, session,
|
|
state->io,
|
|
&state->req);
|
|
if (NT_STATUS_IS_OK(nt_status)) {
|
|
talloc_free(check_req);
|
|
c->status = nt_status;
|
|
composite_continue_smb(c, state->req, request_handler, c);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (!NT_STATUS_IS_OK(c->status)) {
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
os = state->setup.nt1.out.os;
|
|
lanman = state->setup.nt1.out.lanman;
|
|
break;
|
|
|
|
case RAW_SESSSETUP_SPNEGO:
|
|
state->io->out.vuid = state->setup.spnego.out.vuid;
|
|
if (NT_STATUS_EQUAL(c->status, NT_STATUS_LOGON_FAILURE)) {
|
|
const char *principal;
|
|
|
|
/* we need to reset the vuid for a new try */
|
|
session->vuid = 0;
|
|
|
|
principal = gensec_get_target_principal(session->gensec);
|
|
if (principal == NULL) {
|
|
const char *hostname = gensec_get_target_hostname(session->gensec);
|
|
const char *service = gensec_get_target_service(session->gensec);
|
|
if (hostname != NULL && service != NULL) {
|
|
principal = talloc_asprintf(state, "%s/%s", service, hostname);
|
|
}
|
|
}
|
|
if (cli_credentials_failed_kerberos_login(state->io->in.credentials, principal, &state->logon_retries) ||
|
|
cli_credentials_wrong_password(state->io->in.credentials)) {
|
|
struct tevent_req *subreq = NULL;
|
|
|
|
nt_status = session_setup_spnego_restart(c, session, state->io);
|
|
if (!NT_STATUS_IS_OK(nt_status)) {
|
|
DEBUG(1, ("session_setup_spnego_restart() failed: %s\n",
|
|
nt_errstr(nt_status)));
|
|
c->status = nt_status;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
|
|
subreq = gensec_update_send(state, c->event_ctx,
|
|
session->gensec,
|
|
state->setup.spnego.out.secblob);
|
|
if (composite_nomem(subreq, c)) {
|
|
return;
|
|
}
|
|
tevent_req_set_callback(subreq,
|
|
smb_composite_sesssetup_spnego_done1,
|
|
c);
|
|
return;
|
|
}
|
|
}
|
|
if (GENSEC_UPDATE_IS_NTERROR(c->status)) {
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
if (NT_STATUS_EQUAL(state->gensec_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
|
|
struct tevent_req *subreq = NULL;
|
|
|
|
/* The status value here, from the earlier pass at GENSEC is
|
|
* vital to the security of the system. Even if the other end
|
|
* accepts, if GENSEC claims 'MORE_PROCESSING_REQUIRED' then
|
|
* you must keep feeding it blobs, or else the remote
|
|
* host/attacker might avoid mutual authentication
|
|
* requirements */
|
|
|
|
subreq = gensec_update_send(state, c->event_ctx,
|
|
session->gensec,
|
|
state->setup.spnego.out.secblob);
|
|
if (composite_nomem(subreq, c)) {
|
|
return;
|
|
}
|
|
tevent_req_set_callback(subreq,
|
|
smb_composite_sesssetup_spnego_done2,
|
|
c);
|
|
if (NT_STATUS_IS_OK(state->remote_status)) {
|
|
state->check_req = check_req;
|
|
} else {
|
|
TALLOC_FREE(check_req);
|
|
}
|
|
return;
|
|
} else {
|
|
state->setup.spnego.in.secblob = data_blob(NULL, 0);
|
|
}
|
|
|
|
if (cli_credentials_is_anonymous(state->io->in.credentials)) {
|
|
/*
|
|
* anonymous => no signing
|
|
*/
|
|
} else if (NT_STATUS_IS_OK(state->remote_status)) {
|
|
DATA_BLOB session_key;
|
|
|
|
if (state->setup.spnego.in.secblob.length) {
|
|
c->status = NT_STATUS_INTERNAL_ERROR;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
session_key_err = gensec_session_key(session->gensec, session, &session_key);
|
|
if (NT_STATUS_IS_OK(session_key_err)) {
|
|
smb1cli_conn_activate_signing(session->transport->conn,
|
|
session_key,
|
|
null_data_blob);
|
|
}
|
|
|
|
c->status = smb1cli_session_set_session_key(session->smbXcli,
|
|
session_key);
|
|
data_blob_free(&session_key);
|
|
if (!NT_STATUS_IS_OK(c->status)) {
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
}
|
|
|
|
os = state->setup.spnego.out.os;
|
|
lanman = state->setup.spnego.out.lanman;
|
|
break;
|
|
|
|
case RAW_SESSSETUP_SMB2:
|
|
c->status = NT_STATUS_INTERNAL_ERROR;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
|
|
if (check_req) {
|
|
bool ok;
|
|
|
|
check_req->sign_caller_checks = false;
|
|
|
|
ok = smb1cli_conn_check_signing(check_req->transport->conn,
|
|
check_req->in.buffer, 1);
|
|
TALLOC_FREE(check_req);
|
|
if (!ok) {
|
|
c->status = NT_STATUS_ACCESS_DENIED;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!NT_STATUS_IS_OK(c->status)) {
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
|
|
if (os) {
|
|
session->os = talloc_strdup(session, os);
|
|
if (composite_nomem(session->os, c)) return;
|
|
} else {
|
|
session->os = NULL;
|
|
}
|
|
if (lanman) {
|
|
session->lanman = talloc_strdup(session, lanman);
|
|
if (composite_nomem(session->lanman, c)) return;
|
|
} else {
|
|
session->lanman = NULL;
|
|
}
|
|
|
|
composite_done(c);
|
|
}
|
|
|
|
|
|
/*
|
|
send a nt1 style session setup
|
|
*/
|
|
static NTSTATUS session_setup_nt1(struct composite_context *c,
|
|
struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io,
|
|
struct smbcli_request **req)
|
|
{
|
|
NTSTATUS nt_status = NT_STATUS_INTERNAL_ERROR;
|
|
struct sesssetup_state *state = talloc_get_type(c->private_data,
|
|
struct sesssetup_state);
|
|
const char *domain = cli_credentials_get_domain(io->in.credentials);
|
|
|
|
/*
|
|
* domain controllers tend to reject the NTLM v2 blob
|
|
* if the netbiosname is not valid (e.g. IP address or FQDN)
|
|
* so just leave it away (as Windows client do)
|
|
*/
|
|
DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, NULL, domain);
|
|
|
|
DATA_BLOB session_key = data_blob(NULL, 0);
|
|
int flags = CLI_CRED_NTLM_AUTH;
|
|
|
|
if (session->options.lanman_auth) {
|
|
flags |= CLI_CRED_LANMAN_AUTH;
|
|
}
|
|
|
|
if (session->options.ntlmv2_auth) {
|
|
flags |= CLI_CRED_NTLMv2_AUTH;
|
|
}
|
|
|
|
state->setup.nt1.level = RAW_SESSSETUP_NT1;
|
|
state->setup.nt1.in.bufsize = session->transport->options.max_xmit;
|
|
state->setup.nt1.in.mpx_max = session->transport->options.max_mux;
|
|
state->setup.nt1.in.vc_num = 1;
|
|
state->setup.nt1.in.sesskey = io->in.sesskey;
|
|
state->setup.nt1.in.capabilities = io->in.capabilities;
|
|
state->setup.nt1.in.os = "Unix";
|
|
state->setup.nt1.in.lanman = talloc_asprintf(state, "Samba %s", SAMBA_VERSION_STRING);
|
|
|
|
cli_credentials_get_ntlm_username_domain(io->in.credentials, state,
|
|
&state->setup.nt1.in.user,
|
|
&state->setup.nt1.in.domain);
|
|
|
|
|
|
if (session->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) {
|
|
if (!cli_credentials_is_anonymous(io->in.credentials) &&
|
|
session->options.ntlmv2_auth &&
|
|
session->transport->options.use_spnego)
|
|
{
|
|
/*
|
|
* Don't send an NTLMv2_RESPONSE without NTLMSSP
|
|
* if we want to use spnego
|
|
*/
|
|
return NT_STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
nt_status = cli_credentials_get_ntlm_response(io->in.credentials, state,
|
|
&flags,
|
|
session->transport->negotiate.secblob,
|
|
NULL, /* server_timestamp */
|
|
names_blob,
|
|
&state->setup.nt1.in.password1,
|
|
&state->setup.nt1.in.password2,
|
|
NULL, &session_key);
|
|
NT_STATUS_NOT_OK_RETURN(nt_status);
|
|
} else if (session->options.plaintext_auth) {
|
|
const char *password = cli_credentials_get_password(io->in.credentials);
|
|
state->setup.nt1.in.password1 = data_blob_talloc(state, password, strlen(password));
|
|
state->setup.nt1.in.password2 = data_blob(NULL, 0);
|
|
} else {
|
|
/* could match windows client and return 'cannot logon from this workstation', but it just confuses everybody */
|
|
return NT_STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
*req = smb_raw_sesssetup_send(session, &state->setup);
|
|
if (!*req) {
|
|
return NT_STATUS_NO_MEMORY;
|
|
}
|
|
|
|
if (!NT_STATUS_IS_OK(nt_status)) {
|
|
/*
|
|
* plain text => no signing
|
|
*/
|
|
return (*req)->status;
|
|
}
|
|
|
|
if (cli_credentials_is_anonymous(io->in.credentials)) {
|
|
/*
|
|
* anonymous => no signing
|
|
*/
|
|
return (*req)->status;
|
|
}
|
|
|
|
smb1cli_conn_activate_signing(session->transport->conn,
|
|
session_key,
|
|
state->setup.nt1.in.password2);
|
|
|
|
nt_status = smb1cli_session_set_session_key(session->smbXcli,
|
|
session_key);
|
|
data_blob_free(&session_key);
|
|
if (!NT_STATUS_IS_OK(nt_status)) {
|
|
return nt_status;
|
|
}
|
|
|
|
return (*req)->status;
|
|
}
|
|
|
|
|
|
/*
|
|
old style session setup (pre NT1 protocol level)
|
|
*/
|
|
static NTSTATUS session_setup_old(struct composite_context *c,
|
|
struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io,
|
|
struct smbcli_request **req)
|
|
{
|
|
NTSTATUS nt_status;
|
|
struct sesssetup_state *state = talloc_get_type(c->private_data,
|
|
struct sesssetup_state);
|
|
const char *password = cli_credentials_get_password(io->in.credentials);
|
|
|
|
/*
|
|
* domain controllers tend to reject the NTLM v2 blob
|
|
* if the netbiosname is not valid (e.g. IP address or FQDN)
|
|
* so just leave it away (as Windows client do)
|
|
*/
|
|
DATA_BLOB session_key;
|
|
|
|
state->setup.old.level = RAW_SESSSETUP_OLD;
|
|
state->setup.old.in.bufsize = session->transport->options.max_xmit;
|
|
state->setup.old.in.mpx_max = session->transport->options.max_mux;
|
|
state->setup.old.in.vc_num = 1;
|
|
state->setup.old.in.sesskey = io->in.sesskey;
|
|
state->setup.old.in.os = "Unix";
|
|
state->setup.old.in.lanman = talloc_asprintf(state, "Samba %s", SAMBA_VERSION_STRING);
|
|
cli_credentials_get_ntlm_username_domain(io->in.credentials, state,
|
|
&state->setup.old.in.user,
|
|
&state->setup.old.in.domain);
|
|
|
|
if (session->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) {
|
|
DATA_BLOB names_blob = data_blob_null;
|
|
int flags = 0;
|
|
|
|
if (!cli_credentials_is_anonymous(io->in.credentials) &&
|
|
!session->options.lanman_auth)
|
|
{
|
|
return NT_STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
flags |= CLI_CRED_LANMAN_AUTH;
|
|
|
|
nt_status = cli_credentials_get_ntlm_response(io->in.credentials, state,
|
|
&flags,
|
|
session->transport->negotiate.secblob,
|
|
NULL, /* server_timestamp */
|
|
names_blob,
|
|
&state->setup.old.in.password,
|
|
NULL,
|
|
NULL, &session_key);
|
|
NT_STATUS_NOT_OK_RETURN(nt_status);
|
|
|
|
nt_status = smb1cli_session_set_session_key(session->smbXcli,
|
|
session_key);
|
|
data_blob_free(&session_key);
|
|
if (!NT_STATUS_IS_OK(nt_status)) {
|
|
return nt_status;
|
|
}
|
|
} else if (session->options.plaintext_auth) {
|
|
state->setup.old.in.password = data_blob_talloc(state, password, strlen(password));
|
|
} else {
|
|
/* could match windows client and return 'cannot logon from this workstation', but it just confuses everybody */
|
|
return NT_STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
*req = smb_raw_sesssetup_send(session, &state->setup);
|
|
if (!*req) {
|
|
return NT_STATUS_NO_MEMORY;
|
|
}
|
|
return (*req)->status;
|
|
}
|
|
|
|
static NTSTATUS session_setup_spnego_restart(struct composite_context *c,
|
|
struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io)
|
|
{
|
|
struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
|
|
NTSTATUS status;
|
|
|
|
status = gensec_client_start(session, &session->gensec,
|
|
io->in.gensec_settings);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(1, ("Failed to start GENSEC client mode: %s\n", nt_errstr(status)));
|
|
return status;
|
|
}
|
|
|
|
gensec_want_feature(session->gensec, GENSEC_FEATURE_SESSION_KEY);
|
|
|
|
status = gensec_set_credentials(session->gensec, io->in.credentials);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(1, ("Failed to start set GENSEC client credentials: %s\n",
|
|
nt_errstr(status)));
|
|
return status;
|
|
}
|
|
|
|
status = gensec_set_target_hostname(session->gensec,
|
|
smbXcli_conn_remote_name(session->transport->conn));
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(1, ("Failed to start set GENSEC target hostname: %s\n",
|
|
nt_errstr(status)));
|
|
return status;
|
|
}
|
|
|
|
status = gensec_set_target_service(session->gensec, "cifs");
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(1, ("Failed to start set GENSEC target service: %s\n",
|
|
nt_errstr(status)));
|
|
return status;
|
|
}
|
|
|
|
state->setup.spnego.out.secblob =
|
|
session->transport->negotiate.secblob;
|
|
if (session->transport->negotiate.secblob.length) {
|
|
state->chosen_oid = GENSEC_OID_SPNEGO;
|
|
status = gensec_start_mech_by_oid(session->gensec,
|
|
state->chosen_oid);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(1, ("Failed to start set GENSEC client mechanism %s: %s\n",
|
|
gensec_get_name_by_oid(session->gensec,
|
|
state->chosen_oid),
|
|
nt_errstr(status)));
|
|
state->setup.spnego.out.secblob = data_blob_null;
|
|
state->chosen_oid = GENSEC_OID_NTLMSSP;
|
|
status = gensec_start_mech_by_oid(session->gensec,
|
|
state->chosen_oid);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(1, ("Failed to start set (fallback) GENSEC client mechanism %s: %s\n",
|
|
gensec_get_name_by_oid(session->gensec,
|
|
state->chosen_oid),
|
|
nt_errstr(status)));
|
|
return status;
|
|
}
|
|
}
|
|
} else {
|
|
/* without a sec blob, means raw NTLMSSP */
|
|
state->chosen_oid = GENSEC_OID_NTLMSSP;
|
|
status = gensec_start_mech_by_oid(session->gensec,
|
|
state->chosen_oid);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(1, ("Failed to start set GENSEC client mechanism %s: %s\n",
|
|
gensec_get_name_by_oid(session->gensec,
|
|
state->chosen_oid),
|
|
nt_errstr(status)));
|
|
return status;
|
|
}
|
|
}
|
|
|
|
state->gensec_status = NT_STATUS_MORE_PROCESSING_REQUIRED;
|
|
state->remote_status = NT_STATUS_MORE_PROCESSING_REQUIRED;
|
|
return NT_STATUS_OK;
|
|
}
|
|
|
|
/*
|
|
Modern, all singing, all dancing extended security (and possibly SPNEGO) request
|
|
*/
|
|
static NTSTATUS session_setup_spnego(struct composite_context *c,
|
|
struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io,
|
|
struct smbcli_request **req)
|
|
{
|
|
struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
|
|
|
|
state->setup.spnego.level = RAW_SESSSETUP_SPNEGO;
|
|
state->setup.spnego.in.bufsize = session->transport->options.max_xmit;
|
|
state->setup.spnego.in.mpx_max = session->transport->options.max_mux;
|
|
state->setup.spnego.in.vc_num = 1;
|
|
state->setup.spnego.in.sesskey = io->in.sesskey;
|
|
state->setup.spnego.in.capabilities = io->in.capabilities;
|
|
state->setup.spnego.in.os = "Unix";
|
|
state->setup.spnego.in.lanman = talloc_asprintf(state, "Samba %s", SAMBA_VERSION_STRING);
|
|
state->setup.spnego.in.workgroup = io->in.workgroup;
|
|
|
|
*req = smb_raw_sesssetup_send(session, &state->setup);
|
|
if (!*req) {
|
|
return NT_STATUS_NO_MEMORY;
|
|
}
|
|
|
|
/*
|
|
* we need to check the signature ourself
|
|
* as the session key might be the acceptor subkey
|
|
* which comes within the response itself
|
|
*/
|
|
if (!smb1cli_conn_signing_is_active((*req)->transport->conn)) {
|
|
(*req)->sign_caller_checks = true;
|
|
}
|
|
|
|
return (*req)->status;
|
|
}
|
|
|
|
|
|
/*
|
|
composite session setup function that hides the details of all the
|
|
different session setup variants, including the multi-pass nature of
|
|
the spnego variant
|
|
*/
|
|
struct composite_context *smb_composite_sesssetup_send(struct smbcli_session *session,
|
|
struct smb_composite_sesssetup *io)
|
|
{
|
|
struct composite_context *c;
|
|
struct sesssetup_state *state;
|
|
NTSTATUS status;
|
|
enum smb_encryption_setting encryption_state =
|
|
cli_credentials_get_smb_encryption(io->in.credentials);
|
|
enum credentials_use_kerberos krb5_state =
|
|
cli_credentials_get_kerberos_state(io->in.credentials);
|
|
|
|
c = composite_create(session, session->transport->ev);
|
|
if (c == NULL) return NULL;
|
|
|
|
if (encryption_state > SMB_ENCRYPTION_DESIRED) {
|
|
composite_error(c, NT_STATUS_PROTOCOL_NOT_SUPPORTED);
|
|
return c;
|
|
}
|
|
|
|
state = talloc_zero(c, struct sesssetup_state);
|
|
if (composite_nomem(state, c)) return c;
|
|
c->private_data = state;
|
|
|
|
state->session = session;
|
|
state->io = io;
|
|
|
|
talloc_set_destructor(state, sesssetup_state_destructor);
|
|
|
|
/* no session setup at all in earliest protocol variants */
|
|
if (session->transport->negotiate.protocol < PROTOCOL_LANMAN1) {
|
|
if (krb5_state == CRED_USE_KERBEROS_REQUIRED) {
|
|
composite_error(c, NT_STATUS_NETWORK_CREDENTIAL_CONFLICT);
|
|
return c;
|
|
}
|
|
ZERO_STRUCT(io->out);
|
|
composite_done(c);
|
|
return c;
|
|
}
|
|
|
|
/* see what session setup interface we will use */
|
|
if (session->transport->negotiate.protocol < PROTOCOL_NT1) {
|
|
if (krb5_state == CRED_USE_KERBEROS_REQUIRED) {
|
|
composite_error(c, NT_STATUS_NETWORK_CREDENTIAL_CONFLICT);
|
|
return c;
|
|
}
|
|
status = session_setup_old(c, session, io, &state->req);
|
|
} else if (!session->transport->options.use_spnego ||
|
|
!(io->in.capabilities & CAP_EXTENDED_SECURITY)) {
|
|
if (krb5_state == CRED_USE_KERBEROS_REQUIRED) {
|
|
composite_error(c, NT_STATUS_NETWORK_CREDENTIAL_CONFLICT);
|
|
return c;
|
|
}
|
|
status = session_setup_nt1(c, session, io, &state->req);
|
|
} else {
|
|
struct tevent_req *subreq = NULL;
|
|
|
|
status = session_setup_spnego_restart(c, session, io);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
DEBUG(1, ("session_setup_spnego_restart() failed: %s\n",
|
|
nt_errstr(status)));
|
|
c->status = status;
|
|
composite_error(c, c->status);
|
|
return c;
|
|
}
|
|
|
|
subreq = gensec_update_send(state, c->event_ctx,
|
|
session->gensec,
|
|
state->setup.spnego.out.secblob);
|
|
if (composite_nomem(subreq, c)) {
|
|
return c;
|
|
}
|
|
tevent_req_set_callback(subreq,
|
|
smb_composite_sesssetup_spnego_done1,
|
|
c);
|
|
return c;
|
|
}
|
|
|
|
if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) ||
|
|
NT_STATUS_IS_OK(status)) {
|
|
composite_continue_smb(c, state->req, request_handler, c);
|
|
return c;
|
|
}
|
|
|
|
composite_error(c, status);
|
|
return c;
|
|
}
|
|
|
|
static void smb_composite_sesssetup_spnego_done1(struct tevent_req *subreq)
|
|
{
|
|
struct composite_context *c =
|
|
tevent_req_callback_data(subreq,
|
|
struct composite_context);
|
|
struct sesssetup_state *state =
|
|
talloc_get_type_abort(c->private_data,
|
|
struct sesssetup_state);
|
|
NTSTATUS status;
|
|
|
|
status = gensec_update_recv(subreq, state,
|
|
&state->setup.spnego.in.secblob);
|
|
TALLOC_FREE(subreq);
|
|
if (GENSEC_UPDATE_IS_NTERROR(status)) {
|
|
DEBUG(1, ("Failed initial gensec_update with mechanism %s: %s\n",
|
|
gensec_get_name_by_oid(state->session->gensec,
|
|
state->chosen_oid),
|
|
nt_errstr(status)));
|
|
c->status = status;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
state->gensec_status = status;
|
|
|
|
status = session_setup_spnego(c, state->session, state->io, &state->req);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
c->status = status;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
|
|
composite_continue_smb(c, state->req, request_handler, c);
|
|
}
|
|
|
|
static void smb_composite_sesssetup_spnego_done2(struct tevent_req *subreq)
|
|
{
|
|
struct composite_context *c =
|
|
tevent_req_callback_data(subreq,
|
|
struct composite_context);
|
|
struct sesssetup_state *state =
|
|
talloc_get_type_abort(c->private_data,
|
|
struct sesssetup_state);
|
|
struct smbcli_session *session = state->session;
|
|
NTSTATUS status;
|
|
const char *os = NULL;
|
|
const char *lanman = NULL;
|
|
|
|
status = gensec_update_recv(subreq, state,
|
|
&state->setup.spnego.in.secblob);
|
|
TALLOC_FREE(subreq);
|
|
if (GENSEC_UPDATE_IS_NTERROR(status)) {
|
|
DEBUG(1, ("Failed initial gensec_update with mechanism %s: %s\n",
|
|
gensec_get_name_by_oid(state->session->gensec,
|
|
state->chosen_oid),
|
|
nt_errstr(status)));
|
|
c->status = status;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
state->gensec_status = status;
|
|
|
|
if (NT_STATUS_IS_OK(state->remote_status)) {
|
|
if (state->setup.spnego.in.secblob.length) {
|
|
c->status = NT_STATUS_INTERNAL_ERROR;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (state->setup.spnego.in.secblob.length) {
|
|
/*
|
|
* set the session->vuid value only for calling
|
|
* smb_raw_sesssetup_send()
|
|
*/
|
|
uint16_t vuid = session->vuid;
|
|
session->vuid = state->io->out.vuid;
|
|
state->req = smb_raw_sesssetup_send(session, &state->setup);
|
|
session->vuid = vuid;
|
|
if (state->req &&
|
|
!smb1cli_conn_signing_is_active(state->req->transport->conn)) {
|
|
state->req->sign_caller_checks = true;
|
|
}
|
|
composite_continue_smb(c, state->req, request_handler, c);
|
|
return;
|
|
}
|
|
|
|
if (cli_credentials_is_anonymous(state->io->in.credentials)) {
|
|
/*
|
|
* anonymous => no signing
|
|
*/
|
|
} else if (NT_STATUS_IS_OK(state->remote_status)) {
|
|
NTSTATUS session_key_err;
|
|
DATA_BLOB session_key;
|
|
|
|
session_key_err = gensec_session_key(session->gensec, session, &session_key);
|
|
if (NT_STATUS_IS_OK(session_key_err)) {
|
|
smb1cli_conn_activate_signing(session->transport->conn,
|
|
session_key,
|
|
data_blob_null);
|
|
}
|
|
|
|
c->status = smb1cli_session_set_session_key(session->smbXcli,
|
|
session_key);
|
|
data_blob_free(&session_key);
|
|
if (!NT_STATUS_IS_OK(c->status)) {
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
}
|
|
|
|
os = state->setup.spnego.out.os;
|
|
lanman = state->setup.spnego.out.lanman;
|
|
|
|
if (state->check_req) {
|
|
struct smbcli_request *check_req = state->check_req;
|
|
bool ok;
|
|
|
|
check_req->sign_caller_checks = false;
|
|
|
|
ok = smb1cli_conn_check_signing(check_req->transport->conn,
|
|
check_req->in.buffer, 1);
|
|
TALLOC_FREE(check_req);
|
|
if (!ok) {
|
|
c->status = NT_STATUS_ACCESS_DENIED;
|
|
composite_error(c, c->status);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (os) {
|
|
session->os = talloc_strdup(session, os);
|
|
if (composite_nomem(session->os, c)) return;
|
|
} else {
|
|
session->os = NULL;
|
|
}
|
|
if (lanman) {
|
|
session->lanman = talloc_strdup(session, lanman);
|
|
if (composite_nomem(session->lanman, c)) return;
|
|
} else {
|
|
session->lanman = NULL;
|
|
}
|
|
|
|
composite_done(c);
|
|
}
|
|
|
|
/*
|
|
receive a composite session setup reply
|
|
*/
|
|
NTSTATUS smb_composite_sesssetup_recv(struct composite_context *c)
|
|
{
|
|
NTSTATUS status;
|
|
status = composite_wait(c);
|
|
talloc_free(c);
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
sync version of smb_composite_sesssetup
|
|
*/
|
|
NTSTATUS smb_composite_sesssetup(struct smbcli_session *session, struct smb_composite_sesssetup *io)
|
|
{
|
|
struct composite_context *c = smb_composite_sesssetup_send(session, io);
|
|
return smb_composite_sesssetup_recv(c);
|
|
}
|