/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
 */

/*
 * SPNEGO back-end for NTLMSSP.  See [MS-NLMP]
 */

#include <sys/types.h>
#include <sys/byteorder.h>
#include <strings.h>
#include "smbd.h"
#include "smbd_authsvc.h"
#include "netsmb/ntlmssp.h"
#include <assert.h>

/* A shorter alias for a crazy long name from [MS-NLMP] */
#define	NTLMSSP_NEGOTIATE_NTLM2 \
	NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY

/* Need this in a header somewhere */
#ifdef _LITTLE_ENDIAN
/* little-endian values on little-endian */
#define	htolel(x)	((uint32_t)(x))
#define	letohl(x)	((uint32_t)(x))
#else	/* (BYTE_ORDER == LITTLE_ENDIAN) */
/* little-endian values on big-endian (swap) */
#define	letohl(x) 	BSWAP_32(x)
#define	htolel(x) 	BSWAP_32(x)
#endif	/* (BYTE_ORDER == LITTLE_ENDIAN) */

typedef struct ntlmssp_backend {
	uint32_t expect_type;
	uint32_t clnt_flags;
	uint32_t srv_flags;
	char srv_challenge[8];
} ntlmssp_backend_t;

struct genhdr {
	char h_id[8];	/* "NTLMSSP" */
	uint32_t h_type;
};

struct sec_buf {
	uint16_t sb_length;
	uint16_t sb_maxlen;
	uint32_t sb_offset;
};

struct nego_hdr {
	char h_id[8];
	uint32_t h_type;
	uint32_t h_flags;
	/* workstation domain, name (place holders) */
	uint16_t ws_dom[4];
	uint16_t ws_name[4];
};

struct auth_hdr {
	char h_id[8];
	uint32_t h_type;
	struct sec_buf h_lm_resp;
	struct sec_buf h_nt_resp;
	struct sec_buf h_domain;
	struct sec_buf h_user;
	struct sec_buf h_wksta;
	struct sec_buf h_essn_key; /* encrypted session key */
	uint32_t h_flags;
	/* Version struct (optional) */
	/* MIC hash (optional) */
};

/* Allow turning these off for debugging, etc. */
int smbd_signing_enabled = 1;

int smbd_constant_challenge = 0;
static uint8_t constant_chal[8] = {
    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 };

static int smbd_ntlmssp_negotiate(authsvc_context_t *);
static int smbd_ntlmssp_authenticate(authsvc_context_t *);
static int encode_avpair_str(smb_msgbuf_t *, uint16_t, char *);
static int decode_secbuf_bin(smb_msgbuf_t *, struct sec_buf *, void **);
static int decode_secbuf_str(smb_msgbuf_t *, struct sec_buf *, char **);

/*
 * Initialize this context for NTLMSSP, if possible.
 */
int
smbd_ntlmssp_init(authsvc_context_t *ctx)
{
	ntlmssp_backend_t *be;

	be = malloc(sizeof (*be));
	if (be == 0)
		return (NT_STATUS_NO_MEMORY);
	bzero(be, sizeof (*be));
	be->expect_type = NTLMSSP_MSGTYPE_NEGOTIATE;
	ctx->ctx_backend = be;

	return (0);
}

void
smbd_ntlmssp_fini(authsvc_context_t *ctx)
{
	free(ctx->ctx_backend);
}

/*
 * Handle an auth message
 */
int
smbd_ntlmssp_work(authsvc_context_t *ctx)
{
	struct genhdr *ihdr = ctx->ctx_ibodybuf;
	ntlmssp_backend_t *be = ctx->ctx_backend;
	uint32_t mtype;
	int rc;

	if (ctx->ctx_ibodylen < sizeof (*ihdr))
		return (NT_STATUS_INVALID_PARAMETER);

	if (bcmp(ihdr->h_id, "NTLMSSP", 8))
		return (NT_STATUS_INVALID_PARAMETER);
	mtype = letohl(ihdr->h_type);
	if (mtype != be->expect_type)
		return (NT_STATUS_INVALID_PARAMETER);

	switch (mtype) {
	case NTLMSSP_MSGTYPE_NEGOTIATE:
		ctx->ctx_orawtype = LSA_MTYPE_ES_CONT;
		rc = smbd_ntlmssp_negotiate(ctx);
		break;
	case NTLMSSP_MSGTYPE_AUTHENTICATE:
		ctx->ctx_orawtype = LSA_MTYPE_ES_DONE;
		rc = smbd_ntlmssp_authenticate(ctx);
		break;

	default:
	case NTLMSSP_MSGTYPE_CHALLENGE:
		/* Sent by servers, not received. */
		rc = NT_STATUS_INVALID_PARAMETER;
		break;
	}

	return (rc);
}

#if (MAXHOSTNAMELEN < NETBIOS_NAME_SZ)
#error "MAXHOSTNAMELEN < NETBIOS_NAME_SZ"
#endif

/*
 * Handle an NTLMSSP_MSGTYPE_NEGOTIATE message, and reply
 * with an NTLMSSP_MSGTYPE_CHALLENGE message.
 * See: [MS-NLMP] 2.2.1.1, 3.2.5.1.1
 */
static int
smbd_ntlmssp_negotiate(authsvc_context_t *ctx)
{
	char tmp_name[MAXHOSTNAMELEN];
	ntlmssp_backend_t *be = ctx->ctx_backend;
	struct nego_hdr *ihdr = ctx->ctx_ibodybuf;
	smb_msgbuf_t mb;
	uint8_t *save_scan;
	int secmode;
	int mbflags;
	int rc;
	size_t var_start, var_end;
	uint16_t var_size;

	if (ctx->ctx_ibodylen < sizeof (*ihdr))
		return (NT_STATUS_INVALID_PARAMETER);
	be->clnt_flags = letohl(ihdr->h_flags);

	/*
	 * Looks like we can ignore ws_dom, ws_name.
	 * Otherwise would parse those here.
	 */

	secmode = smb_config_get_secmode();
	if (smbd_constant_challenge) {
		(void) memcpy(be->srv_challenge, constant_chal,
		    sizeof (be->srv_challenge));
	} else {
		randomize(be->srv_challenge, sizeof (be->srv_challenge));
	}

	/*
	 * Compute srv_flags
	 */
	be->srv_flags =
	    NTLMSSP_REQUEST_TARGET |
	    NTLMSSP_NEGOTIATE_NTLM |
	    NTLMSSP_NEGOTIATE_TARGET_INFO;
	be->srv_flags |= be->clnt_flags & (
	    NTLMSSP_NEGOTIATE_NTLM2 |
	    NTLMSSP_NEGOTIATE_128 |
	    NTLMSSP_NEGOTIATE_KEY_EXCH |
	    NTLMSSP_NEGOTIATE_56);

	if (smbd_signing_enabled) {
		be->srv_flags |= be->clnt_flags & (
		    NTLMSSP_NEGOTIATE_SIGN |
		    NTLMSSP_NEGOTIATE_SEAL |
		    NTLMSSP_NEGOTIATE_ALWAYS_SIGN);
	}

	if (be->clnt_flags & NTLMSSP_NEGOTIATE_UNICODE)
		be->srv_flags |= NTLMSSP_NEGOTIATE_UNICODE;
	else if (be->clnt_flags & NTLMSSP_NEGOTIATE_OEM)
		be->srv_flags |= NTLMSSP_NEGOTIATE_OEM;

	/* LM Key is mutually exclusive with NTLM2 */
	if ((be->srv_flags & NTLMSSP_NEGOTIATE_NTLM2) == 0 &&
	    (be->clnt_flags & NTLMSSP_NEGOTIATE_LM_KEY) != 0)
		be->srv_flags |= NTLMSSP_NEGOTIATE_LM_KEY;

	/* Get our "target name" */
	if (secmode == SMB_SECMODE_DOMAIN) {
		be->srv_flags |= NTLMSSP_TARGET_TYPE_DOMAIN;
		rc = smb_getdomainname(tmp_name, NETBIOS_NAME_SZ);
	} else {
		be->srv_flags |= NTLMSSP_TARGET_TYPE_SERVER;
		rc = smb_getnetbiosname(tmp_name, NETBIOS_NAME_SZ);
	}
	if (rc)
		goto errout;

	/*
	 * Build the NTLMSSP_MSGTYPE_CHALLENGE message.
	 */
	mbflags = SMB_MSGBUF_NOTERM;
	if (be->srv_flags & NTLMSSP_NEGOTIATE_UNICODE)
		mbflags |= SMB_MSGBUF_UNICODE;
	smb_msgbuf_init(&mb, ctx->ctx_obodybuf, ctx->ctx_obodylen, mbflags);

	/*
	 * Fixed size parts
	 */
	rc = smb_msgbuf_encode(
	    &mb, "8clwwll8cllwwl",	/* offset, name (fmt) */
	    "NTLMSSP",			/* 0: signature (8c) */
	    NTLMSSP_MSGTYPE_CHALLENGE,	/* 8: type	(l) */
	    0, 0, 0,	/* filled later:   12: target name (wwl) */
	    be->srv_flags,		/* 20: flags	(l) */
	    be->srv_challenge,		/* 24: 		(8c) */
	    0, 0,			/* 32: reserved (ll) */
	    0, 0, 0);	/* filled later:   40: target info (wwl) */
#define	TARGET_NAME_OFFSET	12
#define	TARGET_INFO_OFFSET	40
	if (rc < 0)
		goto errout;

	/*
	 * Variable length parts.
	 *
	 * Target name
	 */
	var_start = smb_msgbuf_used(&mb);
	rc = smb_msgbuf_encode(&mb, "u", tmp_name);
	var_end = smb_msgbuf_used(&mb);
	var_size = (uint16_t)(var_end - var_start);
	if (rc < 0)
		goto errout;

	/* overwrite target name offset+lengths */
	save_scan = mb.scan;
	mb.scan = mb.base + TARGET_NAME_OFFSET;
	(void) smb_msgbuf_encode(&mb, "wwl", var_size, var_size, var_start);
	mb.scan = save_scan;

	/*
	 * Target info (AvPairList)
	 *
	 * These AV pairs are like our name/value pairs, but have
	 * numeric identifiers instead of names.  There are many
	 * of these, but we put only the four expected by Windows:
	 *	NetBIOS computer name
	 *	NetBIOS domain name
	 *	DNS computer name
	 *	DNS domain name
	 * Note that "domain" above (even "DNS domain") refers to
	 * the AD domain of which we're a member, which may be
	 * _different_ from the configured DNS domain.
	 *
	 * Also note that in "workgroup" mode (not a domain member)
	 * all "domain" fields should be set to the same values as
	 * the "computer" fields ("bare" host name, not FQDN).
	 */
	var_start = smb_msgbuf_used(&mb);

	/* NetBIOS Computer Name */
	if (smb_getnetbiosname(tmp_name, NETBIOS_NAME_SZ))
		goto errout;
	if (encode_avpair_str(&mb, MsvAvNbComputerName, tmp_name) < 0)
		goto errout;

	if (secmode != SMB_SECMODE_DOMAIN) {
		/*
		 * Workgroup mode.  Set all to hostname.
		 * tmp_name = netbios hostname from above.
		 */
		if (encode_avpair_str(&mb, MsvAvNbDomainName, tmp_name) < 0)
			goto errout;
		/*
		 * Want the bare computer name here (not FQDN).
		 */
		if (smb_gethostname(tmp_name, MAXHOSTNAMELEN, SMB_CASE_LOWER))
			goto errout;
		if (encode_avpair_str(&mb, MsvAvDnsComputerName, tmp_name) < 0)
			goto errout;
		if (encode_avpair_str(&mb, MsvAvDnsDomainName, tmp_name) < 0)
			goto errout;
	} else {
		/*
		 * Domain mode.  Use real host and domain values.
		 */

		/* NetBIOS Domain Name */
		if (smb_getdomainname(tmp_name, NETBIOS_NAME_SZ))
			goto errout;
		if (encode_avpair_str(&mb, MsvAvNbDomainName, tmp_name) < 0)
			goto errout;

		/* DNS Computer Name */
		if (smb_getfqhostname(tmp_name, MAXHOSTNAMELEN))
			goto errout;
		if (encode_avpair_str(&mb, MsvAvDnsComputerName, tmp_name) < 0)
			goto errout;

		/* DNS Domain Name */
		if (smb_getfqdomainname(tmp_name, MAXHOSTNAMELEN))
			goto errout;
		if (encode_avpair_str(&mb, MsvAvDnsDomainName, tmp_name) < 0)
			goto errout;
	}

	/* End marker */
	if (smb_msgbuf_encode(&mb, "ww", MsvAvEOL, 0) < 0)
		goto errout;
	var_end = smb_msgbuf_used(&mb);
	var_size = (uint16_t)(var_end - var_start);

	/* overwrite target  offset+lengths */
	save_scan = mb.scan;
	mb.scan = mb.base + TARGET_INFO_OFFSET;
	(void) smb_msgbuf_encode(&mb, "wwl", var_size, var_size, var_start);
	mb.scan = save_scan;

	ctx->ctx_obodylen = smb_msgbuf_used(&mb);
	smb_msgbuf_term(&mb);

	be->expect_type = NTLMSSP_MSGTYPE_AUTHENTICATE;

	return (0);

errout:
	smb_msgbuf_term(&mb);
	return (NT_STATUS_INTERNAL_ERROR);
}

static int
encode_avpair_str(smb_msgbuf_t *mb, uint16_t AvId, char *name)
{
	int rc;
	uint16_t len;

	len = smb_wcequiv_strlen(name);
	rc = smb_msgbuf_encode(mb, "wwU", AvId, len, name);
	return (rc);
}

/*
 * Handle an NTLMSSP_MSGTYPE_AUTHENTICATE message.
 * See: [MS-NLMP] 2.2.1.3, 3.2.5.1.2
 */
static int
smbd_ntlmssp_authenticate(authsvc_context_t *ctx)
{
	struct auth_hdr hdr;
	smb_msgbuf_t mb;
	smb_logon_t	user_info;
	smb_token_t	*token = NULL;
	ntlmssp_backend_t *be = ctx->ctx_backend;
	void *lm_resp;
	void *nt_resp;
	char *domain;
	char *user;
	char *wksta;
	void *essn_key;	/* encrypted session key (optional) */
	int mbflags;
	uint_t status = NT_STATUS_INTERNAL_ERROR;
	char combined_challenge[SMBAUTH_CHAL_SZ];
	unsigned char kxkey[SMBAUTH_HASH_SZ];
	boolean_t ntlm_v1x = B_FALSE;

	bzero(&user_info, sizeof (user_info));

	/*
	 * Parse the NTLMSSP_MSGTYPE_AUTHENTICATE message.
	 */
	if (ctx->ctx_ibodylen < sizeof (hdr))
		return (NT_STATUS_INVALID_PARAMETER);
	mbflags = SMB_MSGBUF_NOTERM;
	if (be->srv_flags & NTLMSSP_NEGOTIATE_UNICODE)
		mbflags |= SMB_MSGBUF_UNICODE;
	smb_msgbuf_init(&mb, ctx->ctx_ibodybuf, ctx->ctx_ibodylen, mbflags);
	bzero(&hdr, sizeof (hdr));

	if (smb_msgbuf_decode(&mb, "12.") < 0)
		goto errout;
	if (decode_secbuf_bin(&mb, &hdr.h_lm_resp, &lm_resp) < 0)
		goto errout;
	if (decode_secbuf_bin(&mb, &hdr.h_nt_resp, &nt_resp) < 0)
		goto errout;
	if (decode_secbuf_str(&mb, &hdr.h_domain, &domain) < 0)
		goto errout;
	if (decode_secbuf_str(&mb, &hdr.h_user, &user) < 0)
		goto errout;
	if (decode_secbuf_str(&mb, &hdr.h_wksta, &wksta) < 0)
		goto errout;
	if (decode_secbuf_bin(&mb, &hdr.h_essn_key, &essn_key) < 0)
		goto errout;
	if (smb_msgbuf_decode(&mb, "l", &be->clnt_flags) < 0)
		goto errout;

	if (be->clnt_flags & NTLMSSP_NEGOTIATE_KEY_EXCH) {
		if (hdr.h_essn_key.sb_length < 16 || essn_key == NULL)
			goto errout;
	}

	user_info.lg_level = NETR_NETWORK_LOGON;
	user_info.lg_flags = 0;

	user_info.lg_ntlm_flags = be->clnt_flags;
	user_info.lg_username = (user) ? user : "";
	user_info.lg_domain = (domain) ? domain : "";
	user_info.lg_workstation = (wksta) ? wksta : "";

	user_info.lg_clnt_ipaddr =
	    ctx->ctx_clinfo.lci_clnt_ipaddr;
	user_info.lg_local_port = 445;

	user_info.lg_challenge_key.len = SMBAUTH_CHAL_SZ;
	user_info.lg_challenge_key.val = (uint8_t *)be->srv_challenge;

	user_info.lg_nt_password.len = hdr.h_nt_resp.sb_length;
	user_info.lg_nt_password.val = nt_resp;

	user_info.lg_lm_password.len = hdr.h_lm_resp.sb_length;
	user_info.lg_lm_password.val = lm_resp;

	user_info.lg_native_os = ctx->ctx_clinfo.lci_native_os;
	user_info.lg_native_lm = ctx->ctx_clinfo.lci_native_lm;

	/*
	 * If we're doing extended session security, the challenge
	 * this OWF was computed with is different. [MS-NLMP 3.3.1]
	 * It's: MD5(concat(ServerChallenge,ClientChallenge))
	 * where the ClientChallenge is in the LM resp. field.
	 */
	if (user_info.lg_nt_password.len == SMBAUTH_LM_RESP_SZ &&
	    user_info.lg_lm_password.len >= SMBAUTH_CHAL_SZ &&
	    (be->clnt_flags & NTLMSSP_NEGOTIATE_NTLM2) != 0) {
		smb_auth_ntlm2_mkchallenge(combined_challenge,
		    be->srv_challenge, lm_resp);
		user_info.lg_challenge_key.val =
		    (uint8_t *)combined_challenge;
		user_info.lg_lm_password.len = 0;
		ntlm_v1x = B_TRUE;
	}

	/*
	 * This (indirectly) calls smb_auth_validate() to
	 * check that the client gave us a valid hash.
	 */
	token = smbd_user_auth_logon(&user_info);
	if (token == NULL) {
		status = NT_STATUS_ACCESS_DENIED;
		goto errout;
	}

	if (token->tkn_ssnkey.val != NULL &&
	    token->tkn_ssnkey.len == SMBAUTH_HASH_SZ) {

		/*
		 * At this point, token->tkn_session_key is the
		 * "Session Base Key" [MS-NLMP] 3.2.5.1.2
		 * Compute the final session key.  First need the
		 * "Key Exchange Key" [MS-NLMP] 3.4.5.1
		 */
		if (ntlm_v1x) {
			smb_auth_ntlm2_kxkey(kxkey,
			    be->srv_challenge, lm_resp,
			    token->tkn_ssnkey.val);
		} else {
			/* KXKEY is the Session Base Key. */
			(void) memcpy(kxkey, token->tkn_ssnkey.val,
			    SMBAUTH_HASH_SZ);
		}

		/*
		 * If the client give us an encrypted session key,
		 * decrypt it (RC4) using the "key exchange key".
		 */
		if (be->clnt_flags & NTLMSSP_NEGOTIATE_KEY_EXCH) {
			/* RC4 args: result, key, data */
			(void) smb_auth_RC4(token->tkn_ssnkey.val,
			    SMBAUTH_HASH_SZ, kxkey, SMBAUTH_HASH_SZ,
			    essn_key, hdr.h_essn_key.sb_length);
		} else {
			/* Final key is the KXKEY */
			(void) memcpy(token->tkn_ssnkey.val, kxkey,
			    SMBAUTH_HASH_SZ);
		}
	}

	ctx->ctx_token = token;
	ctx->ctx_obodylen = 0;

	smb_msgbuf_term(&mb);
	return (0);

errout:
	smb_msgbuf_term(&mb);
	return (status);
}

static int
decode_secbuf_bin(smb_msgbuf_t *mb, struct sec_buf *sb, void **binp)
{
	int rc;

	*binp = NULL;
	rc = smb_msgbuf_decode(
	    mb, "wwl",
	    &sb->sb_length,
	    &sb->sb_maxlen,
	    &sb->sb_offset);
	if (rc < 0)
		return (rc);

	if (sb->sb_offset > mb->max)
		return (SMB_MSGBUF_UNDERFLOW);
	if (sb->sb_length > (mb->max - sb->sb_offset))
		return (SMB_MSGBUF_UNDERFLOW);
	if (sb->sb_length == 0)
		return (rc);

	*binp = mb->base + sb->sb_offset;
	return (0);
}

static int
decode_secbuf_str(smb_msgbuf_t *mb, struct sec_buf *sb, char **cpp)
{
	uint8_t *save_scan;
	int rc;

	*cpp = NULL;
	rc = smb_msgbuf_decode(
	    mb, "wwl",
	    &sb->sb_length,
	    &sb->sb_maxlen,
	    &sb->sb_offset);
	if (rc < 0)
		return (rc);

	if (sb->sb_offset > mb->max)
		return (SMB_MSGBUF_UNDERFLOW);
	if (sb->sb_length > (mb->max - sb->sb_offset))
		return (SMB_MSGBUF_UNDERFLOW);
	if (sb->sb_length == 0)
		return (rc);

	save_scan = mb->scan;
	mb->scan = mb->base + sb->sb_offset;
	rc = smb_msgbuf_decode(mb, "#u", (int)sb->sb_length, cpp);
	mb->scan = save_scan;

	return (rc);
}