path: root/source4/smb_server/sesssetup.c

/* 
   Unix SMB/CIFS implementation.
   handle SMBsessionsetup
   Copyright (C) Andrew Tridgell 1998-2001
   Copyright (C) Andrew Bartlett      2001
   Copyright (C) Jim McDonough        2002
   Copyright (C) Luke Howard          2003

   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 2 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, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "includes.h"

/*
  setup the OS, Lanman and domain portions of a session setup reply
*/
static void sesssetup_common_strings(struct smbsrv_request *req,
				     char **os, char **lanman, char **domain)
{
	(*os) = talloc_asprintf(req, "Unix");
	(*lanman) = talloc_asprintf(req, "Samba %s", SAMBA_VERSION_STRING);
	(*domain) = talloc_asprintf(req, "%s", lp_workgroup());
}


/*
  handler for old style session setup
*/
static NTSTATUS sesssetup_old(struct smbsrv_request *req, union smb_sesssetup *sess)
{
	NTSTATUS status;
	struct auth_usersupplied_info *user_info = NULL;
	struct auth_serversupplied_info *server_info = NULL;
	struct auth_session_info *session_info;

	TALLOC_CTX *mem_ctx = talloc_named(req, 0, "NT1 session setup");
	char *remote_machine;
	if (!mem_ctx) {
		return NT_STATUS_NO_MEMORY;
	}
	
	if (!req->smb_conn->negotiate.done_sesssetup) {
		req->smb_conn->negotiate.max_send = sess->old.in.bufsize;
	}
	
	remote_machine = socket_get_peer_addr(req->smb_conn->connection->socket, mem_ctx);
	status = make_user_info_for_reply_enc(req->smb_conn,
					      &user_info, 
					      sess->old.in.user, sess->old.in.domain,
					      remote_machine,
					      sess->old.in.password,
					      data_blob(NULL, 0));
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(mem_ctx);
		return NT_STATUS_ACCESS_DENIED;
	}

	status = req->smb_conn->negotiate.auth_context->check_ntlm_password(req->smb_conn->negotiate.auth_context, 
									    user_info, 
									    mem_ctx, 
									    &server_info);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(mem_ctx);
		return nt_status_squash(status);
	}

	/* This references server_info into session_info */
	status = make_session_info(req, server_info, &session_info);
	talloc_free(mem_ctx);
	if (!NT_STATUS_IS_OK(status)) {
		return nt_status_squash(status);
	}

	sess->old.out.action = 0;
	sess->old.out.vuid = smbsrv_register_session(req->smb_conn, session_info, NULL);
	if (sess->old.out.vuid == UID_FIELD_INVALID) {
		return NT_STATUS_ACCESS_DENIED;
	}
	sesssetup_common_strings(req, 
				 &sess->old.out.os,
				 &sess->old.out.lanman,
				 &sess->old.out.domain);

	req->session = smbsrv_session_find(req->smb_conn, sess->old.out.vuid);

	return NT_STATUS_OK;
}


/*
  handler for NT1 style session setup
*/
static NTSTATUS sesssetup_nt1(struct smbsrv_request *req, union smb_sesssetup *sess)
{
	NTSTATUS status;
	struct auth_usersupplied_info *user_info = NULL;
	struct auth_serversupplied_info *server_info = NULL;
	struct auth_session_info *session_info;
	TALLOC_CTX *mem_ctx = talloc_named(req, 0, "NT1 session setup");
	
	if (!mem_ctx) {
		return NT_STATUS_NO_MEMORY;
	}

	if (!req->smb_conn->negotiate.done_sesssetup) {
		req->smb_conn->negotiate.max_send = sess->nt1.in.bufsize;
		req->smb_conn->negotiate.client_caps = sess->nt1.in.capabilities;
	}

	if (req->smb_conn->negotiate.spnego_negotiated) {
		struct auth_context *auth_context;

		if (sess->nt1.in.user && *sess->nt1.in.user) {
			return NT_STATUS_ACCESS_DENIED;
		} else {
			make_user_info_guest(req->smb_conn, &user_info);
		}
		
		status = make_auth_context_subsystem(req->smb_conn, &auth_context);

		if (!NT_STATUS_IS_OK(status)) {
			talloc_free(mem_ctx);
			return status;
		}
		
		status = auth_context->check_ntlm_password(auth_context, 
							   user_info, 
							   mem_ctx,
							   &server_info);
	} else {
		char *remote_machine;
		remote_machine = socket_get_peer_addr(req->smb_conn->connection->socket, mem_ctx);
		status = make_user_info_for_reply_enc(req->smb_conn,
						      &user_info, 
						      sess->nt1.in.user, sess->nt1.in.domain,
						      remote_machine,
						      sess->nt1.in.password1,
						      sess->nt1.in.password2);
		if (!NT_STATUS_IS_OK(status)) {
			talloc_free(mem_ctx);
			return NT_STATUS_ACCESS_DENIED;
		}
		
		status = req->smb_conn->negotiate
			.auth_context->check_ntlm_password(req->smb_conn->negotiate
							   .auth_context, 
							   user_info, 
							   req,
							   &server_info);
	}

	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(mem_ctx);
		return nt_status_squash(status);
	}

	/* This references server_info into session_info */
	status = make_session_info(mem_ctx, server_info, &session_info);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(mem_ctx);
		return nt_status_squash(status);
	}

	sess->nt1.out.action = 0;
	sess->nt1.out.vuid = smbsrv_register_session(req->smb_conn, session_info, NULL);
	talloc_free(mem_ctx);
	if (sess->nt1.out.vuid == UID_FIELD_INVALID) {
		return NT_STATUS_ACCESS_DENIED;
	}
	sesssetup_common_strings(req, 
				 &sess->nt1.out.os,
				 &sess->nt1.out.lanman,
				 &sess->nt1.out.domain);
	
	req->session = smbsrv_session_find(req->smb_conn, sess->nt1.out.vuid);
	if (session_info->server_info->guest) {
		return NT_STATUS_OK;
	}
	if (!srv_setup_signing(req->smb_conn, &session_info->session_key, &sess->nt1.in.password2)) {
		/* Already signing, or disabled */
		return NT_STATUS_OK;
	}
		
	/* Force check of the request packet, now we know the session key */
	req_signing_check_incoming(req);

	srv_signing_restart(req->smb_conn,  &session_info->session_key, &sess->nt1.in.password2);

	return NT_STATUS_OK;
}


/*
  handler for SPNEGO style session setup
*/
static NTSTATUS sesssetup_spnego(struct smbsrv_request *req, union smb_sesssetup *sess)
{
	NTSTATUS status = NT_STATUS_ACCESS_DENIED;
	struct smbsrv_session *smb_sess;
	struct gensec_security *gensec_ctx = NULL;
	struct auth_session_info *session_info = NULL;
	uint16_t vuid;

	if (!req->smb_conn->negotiate.done_sesssetup) {
		req->smb_conn->negotiate.max_send = sess->nt1.in.bufsize;
		req->smb_conn->negotiate.client_caps = sess->nt1.in.capabilities;
	}

	vuid = SVAL(req->in.hdr,HDR_UID);
	smb_sess = smbsrv_session_find(req->smb_conn, vuid);
	if (smb_sess && !smb_sess->session_info) {
		if (!smb_sess->gensec_ctx) {
			return NT_STATUS_INVALID_HANDLE;
		}

		status = gensec_update(smb_sess->gensec_ctx, req, sess->spnego.in.secblob, &sess->spnego.out.secblob);
	} else {
		smb_sess = NULL;

		status = gensec_server_start(req->smb_conn, &gensec_ctx);
		if (!NT_STATUS_IS_OK(status)) {
			DEBUG(1, ("Failed to start GENSEC server code: %s\n", nt_errstr(status)));
			return status;
		}

		gensec_want_feature(gensec_ctx, GENSEC_WANT_SESSION_KEY);

		status = gensec_start_mech_by_oid(gensec_ctx, OID_SPNEGO);
		if (!NT_STATUS_IS_OK(status)) {
			DEBUG(1, ("Failed to start GENSEC SPNEGO server code: %s\n", nt_errstr(status)));
			return status;
		}

		status = gensec_update(gensec_ctx, req, sess->spnego.in.secblob, &sess->spnego.out.secblob);

	}

	if (!smb_sess) {
		vuid = smbsrv_register_session(req->smb_conn, 
					       session_info, gensec_ctx);
		if (vuid == UID_FIELD_INVALID) {
			return NT_STATUS_ACCESS_DENIED;
		}
		smb_sess = smbsrv_session_find(req->smb_conn, vuid);
		if (!smb_sess) {
			return NT_STATUS_FOOBAR;
		}
	}

	if (NT_STATUS_IS_OK(status)) {
		DATA_BLOB session_key;
		
		status = gensec_session_info(smb_sess->gensec_ctx, &smb_sess->session_info);
		if (!NT_STATUS_IS_OK(status)) {
			return status;
		}
		
		status = gensec_session_key(smb_sess->gensec_ctx, 
					    &session_key);
		if (NT_STATUS_IS_OK(status) 
		    && !smb_sess->session_info->server_info->guest
		    && srv_setup_signing(req->smb_conn, &session_key, NULL)) {
			/* Force check of the request packet, now we know the session key */
			req_signing_check_incoming(req);

			srv_signing_restart(req->smb_conn, &session_key, NULL);

		}
	} else {
		status = nt_status_squash(status);
		if (smb_sess->gensec_ctx && 
		    !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
			gensec_end(&smb_sess->gensec_ctx);
		}
	}

	sess->spnego.out.action = 0;
	sess->spnego.out.vuid = vuid;
	sesssetup_common_strings(req, 
				 &sess->spnego.out.os,
				 &sess->spnego.out.lanman,
				 &sess->spnego.out.domain);

	return status;
}

/*
  backend for sessionsetup call - this takes all 3 variants of the call
*/
NTSTATUS sesssetup_backend(struct smbsrv_request *req, 
			   union smb_sesssetup *sess)
{
	NTSTATUS status = NT_STATUS_INVALID_LEVEL;

	switch (sess->generic.level) {
		case RAW_SESSSETUP_GENERIC:
			status = NT_STATUS_INVALID_LEVEL;
			break;
		case RAW_SESSSETUP_OLD:
			status = sesssetup_old(req, sess);
			break;
		case RAW_SESSSETUP_NT1:
			status = sesssetup_nt1(req, sess);
			break;
		case RAW_SESSSETUP_SPNEGO:
			status = sesssetup_spnego(req, sess);
			break;
	}

	if (NT_STATUS_IS_OK(status)) {
		req->smb_conn->negotiate.done_sesssetup = True;
	}

	return status;
}