/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Network Level Authentication (NLA)

 *

 * Copyright 2010-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2015 Thincast Technologies GmbH

 * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>

 * Copyright 2016 Martin Fleisz <martin.fleisz@thincast.com>

 * Copyright 2017 Dorian Ducournau <dorian.ducournau@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *		 http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <time.h>

#ifndef _WIN32

#include <unistd.h>

#endif

#include <freerdp/log.h>

#include <freerdp/crypto/tls.h>

#include <freerdp/build-config.h>

#include <freerdp/peer.h>

#include <winpr/crt.h>

#include <winpr/sam.h>

#include <winpr/sspi.h>

#include <winpr/print.h>

#include <winpr/tchar.h>

#include <winpr/dsparse.h>

#include <winpr/library.h>

#include <winpr/registry.h>

#include "nla.h"

#define TAG FREERDP_TAG("core.nla")

#define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Server"

/**

 * TSRequest ::= SEQUENCE {

 * 	version    [0] INTEGER,

 * 	negoTokens [1] NegoData OPTIONAL,

 * 	authInfo   [2] OCTET STRING OPTIONAL,

 * 	pubKeyAuth [3] OCTET STRING OPTIONAL,

 * 	errorCode  [4] INTEGER OPTIONAL

 * }

 *

 * NegoData ::= SEQUENCE OF NegoDataItem

 *

 * NegoDataItem ::= SEQUENCE {

 * 	negoToken [0] OCTET STRING

 * }

 *

 * TSCredentials ::= SEQUENCE {

 * 	credType    [0] INTEGER,

 * 	credentials [1] OCTET STRING

 * }

 *

 * TSPasswordCreds ::= SEQUENCE {

 * 	domainName  [0] OCTET STRING,

 * 	userName    [1] OCTET STRING,

 * 	password    [2] OCTET STRING

 * }

 *

 * TSSmartCardCreds ::= SEQUENCE {

 * 	pin        [0] OCTET STRING,

 * 	cspData    [1] TSCspDataDetail,

 * 	userHint   [2] OCTET STRING OPTIONAL,

 * 	domainHint [3] OCTET STRING OPTIONAL

 * }

 *

 * TSCspDataDetail ::= SEQUENCE {

 * 	keySpec       [0] INTEGER,

 * 	cardName      [1] OCTET STRING OPTIONAL,

 * 	readerName    [2] OCTET STRING OPTIONAL,

 * 	containerName [3] OCTET STRING OPTIONAL,

 * 	cspName       [4] OCTET STRING OPTIONAL

 * }

 *

 */

#define NLA_PKG_NAME NEGO_SSP_NAME

#define TERMSRV_SPN_PREFIX "TERMSRV/"

struct rdp_nla

{

	BOOL server;

	NLA_STATE state;

	int sendSeqNum;

	int recvSeqNum;

	freerdp* instance;

	CtxtHandle context;

	LPTSTR SspiModule;

	char* SamFile;

	rdpSettings* settings;

	rdpTransport* transport;

	UINT32 cbMaxToken;

#if defined(UNICODE)

	SEC_WCHAR* packageName;

#else

	SEC_CHAR* packageName;

#endif

	UINT32 version;

	UINT32 peerVersion;

	UINT32 errorCode;

	ULONG fContextReq;

	ULONG pfContextAttr;

	BOOL haveContext;

	BOOL haveInputBuffer;

	BOOL havePubKeyAuth;

	SECURITY_STATUS status;

	CredHandle credentials;

	TimeStamp expiration;

	PSecPkgInfo pPackageInfo;

	SecBuffer inputBuffer;

	SecBuffer outputBuffer;

	SecBufferDesc inputBufferDesc;

	SecBufferDesc outputBufferDesc;

	SecBuffer negoToken;

	SecBuffer pubKeyAuth;

	SecBuffer authInfo;

	SecBuffer ClientNonce;

	SecBuffer PublicKey;

	SecBuffer tsCredentials;

	LPTSTR ServicePrincipalName;

	SEC_WINNT_AUTH_IDENTITY* identity;

	PSecurityFunctionTable table;

	SecPkgContext_Sizes ContextSizes;

};

static BOOL nla_send(rdpNla* nla);

static int nla_recv(rdpNla* nla);

static void nla_buffer_print(rdpNla* nla);

static void nla_buffer_free(rdpNla* nla);

static SECURITY_STATUS nla_encrypt_public_key_echo(rdpNla* nla);

static SECURITY_STATUS nla_encrypt_public_key_hash(rdpNla* nla);

static SECURITY_STATUS nla_decrypt_public_key_echo(rdpNla* nla);

static SECURITY_STATUS nla_decrypt_public_key_hash(rdpNla* nla);

static SECURITY_STATUS nla_encrypt_ts_credentials(rdpNla* nla);

static SECURITY_STATUS nla_decrypt_ts_credentials(rdpNla* nla);

static BOOL nla_read_ts_password_creds(rdpNla* nla, wStream* s);

static void nla_identity_free(SEC_WINNT_AUTH_IDENTITY* identity);

#define ber_sizeof_sequence_octet_string(length) \

	ber_sizeof_contextual_tag(ber_sizeof_octet_string(length)) + ber_sizeof_octet_string(length)

#define ber_write_sequence_octet_string(stream, context, value, length)                \

	ber_write_contextual_tag(stream, context, ber_sizeof_octet_string(length), TRUE) + \

	    ber_write_octet_string(stream, value, length)

/* CredSSP Client-To-Server Binding Hash\0 */

static const BYTE ClientServerHashMagic[] = { 0x43, 0x72, 0x65, 0x64, 0x53, 0x53, 0x50, 0x20,

	                                          0x43, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x2D, 0x54,

	                                          0x6F, 0x2D, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72,

	                                          0x20, 0x42, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67,

	                                          0x20, 0x48, 0x61, 0x73, 0x68, 0x00 };

/* CredSSP Server-To-Client Binding Hash\0 */

static const BYTE ServerClientHashMagic[] = { 0x43, 0x72, 0x65, 0x64, 0x53, 0x53, 0x50, 0x20,

	                                          0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2D, 0x54,

	                                          0x6F, 0x2D, 0x43, 0x6C, 0x69, 0x65, 0x6E, 0x74,

	                                          0x20, 0x42, 0x69, 0x6E, 0x64, 0x69, 0x6E, 0x67,

	                                          0x20, 0x48, 0x61, 0x73, 0x68, 0x00 };

static const UINT32 NonceLength = 32;

void nla_identity_free(SEC_WINNT_AUTH_IDENTITY* identity)

{

	if (identity)

	{

		/* Password authentication */

		if (identity->User)

		{

			memset(identity->User, 0, identity->UserLength * 2);

			free(identity->User);

		}

		if (identity->Password)

		{

			size_t len = identity->PasswordLength;

			if (len > LB_PASSWORD_MAX_LENGTH) /* [pth] Password hash */

				len -= LB_PASSWORD_MAX_LENGTH;

			memset(identity->Password, 0, len * 2);

			free(identity->Password);

		}

		if (identity->Domain)

		{

			memset(identity->Domain, 0, identity->DomainLength * 2);

			free(identity->Domain);

		}

	}

	free(identity);

}

/**

 * Initialize NTLM/Kerberos SSP authentication module (client).

 * @param credssp

 */

static BOOL is_empty(const char* str)

{

	if (!str)

		return TRUE;

	if (strlen(str) == 0)

		return TRUE;

	return FALSE;

}

static int nla_client_init(rdpNla* nla)

{

	char* spn;

	size_t length;

	rdpTls* tls = NULL;

	BOOL PromptPassword = FALSE;

	freerdp* instance = nla->instance;

	rdpSettings* settings = nla->settings;

	WINPR_SAM* sam;

	WINPR_SAM_ENTRY* entry;

	nla->state = NLA_STATE_INITIAL;

	if (settings->RestrictedAdminModeRequired)

		settings->DisableCredentialsDelegation = TRUE;

	if (is_empty(settings->Username) ||

	    (is_empty(settings->Password) && is_empty((const char*)settings->RedirectionPassword)))

	{

		PromptPassword = TRUE;

	}

	if (PromptPassword && !is_empty(settings->Username))

	{

		sam = SamOpen(NULL, TRUE);

		if (sam)

		{

			entry = SamLookupUserA(sam, settings->Username, strlen(settings->Username), NULL, 0);

			if (entry)

			{

				/**

				 * The user could be found in SAM database.

				 * Use entry in SAM database later instead of prompt

				 */

				PromptPassword = FALSE;

				SamFreeEntry(sam, entry);

			}

			SamClose(sam);

		}

	}

#ifndef _WIN32

	if (PromptPassword)

	{

		if (settings->RestrictedAdminModeRequired)

		{

			if (!is_empty(settings->PasswordHash))

				PromptPassword = FALSE;

		}

	}

#endif

	if (PromptPassword)

	{

		if (freerdp_shall_disconnect(instance))

			return 0;

		if (!instance->Authenticate)

		{

			freerdp_set_last_error_log(instance->context,

			                           FREERDP_ERROR_CONNECT_NO_OR_MISSING_CREDENTIALS);

			return 0;

		}

		else

		{

			BOOL proceed = instance->Authenticate(instance, &settings->Username,

			                                      &settings->Password, &settings->Domain);

			if (!proceed)

			{

				freerdp_set_last_error_log(instance->context,

				                           FREERDP_ERROR_CONNECT_NO_OR_MISSING_CREDENTIALS);

				return 0;

			}

		}

	}

	if (!settings->Username)

	{

		nla_identity_free(nla->identity);

		nla->identity = NULL;

	}

	else

	{

		if (settings->RedirectionPassword && settings->RedirectionPasswordLength > 0)

		{

			if (sspi_SetAuthIdentityWithUnicodePassword(

			        nla->identity, settings->Username, settings->Domain,

			        (UINT16*)settings->RedirectionPassword,

			        settings->RedirectionPasswordLength / sizeof(WCHAR) - 1) < 0)

				return -1;

		}

		else

		{

			BOOL usePassword = TRUE;

			if (settings->RestrictedAdminModeRequired)

			{

				if (settings->PasswordHash)

				{

					if (strlen(settings->PasswordHash) == 32)

					{

						if (sspi_SetAuthIdentity(nla->identity, settings->Username,

						                         settings->Domain, settings->PasswordHash) < 0)

							return -1;

						/**

						 * Increase password hash length by LB_PASSWORD_MAX_LENGTH to obtain a

						 * length exceeding the maximum (LB_PASSWORD_MAX_LENGTH) and use it this for

						 * hash identification in WinPR.

						 */

						nla->identity->PasswordLength += LB_PASSWORD_MAX_LENGTH;

						usePassword = FALSE;

					}

				}

			}

			if (usePassword)

			{

				if (sspi_SetAuthIdentity(nla->identity, settings->Username, settings->Domain,

				                         settings->Password) < 0)

					return -1;

			}

		}

	}

	tls = nla->transport->tls;

	if (!tls)

	{

		WLog_ERR(TAG, "Unknown NLA transport layer");

		return -1;

	}

	if (!sspi_SecBufferAlloc(&nla->PublicKey, tls->PublicKeyLength))

	{

		WLog_ERR(TAG, "Failed to allocate sspi secBuffer");

		return -1;

	}

	CopyMemory(nla->PublicKey.pvBuffer, tls->PublicKey, tls->PublicKeyLength);

	length = sizeof(TERMSRV_SPN_PREFIX) + strlen(settings->ServerHostname);

	spn = (SEC_CHAR*)malloc(length + 1);

	if (!spn)

		return -1;

	sprintf_s(spn, length + 1, "%s%s", TERMSRV_SPN_PREFIX, settings->ServerHostname);

#ifdef UNICODE

	nla->ServicePrincipalName = NULL;

	ConvertToUnicode(CP_UTF8, 0, spn, -1, &nla->ServicePrincipalName, 0);

	free(spn);

#else

	nla->ServicePrincipalName = spn;

#endif

	nla->table = InitSecurityInterfaceEx(0);

#ifdef WITH_GSSAPI /* KERBEROS SSP */

	nla->status = nla->table->QuerySecurityPackageInfo(KERBEROS_SSP_NAME, &nla->pPackageInfo);

	if (nla->status != SEC_E_OK)

	{

		WLog_ERR(TAG, "QuerySecurityPackageInfo status %s [0x%08" PRIX32 "]",

		         GetSecurityStatusString(nla->status), nla->status);

		return -1;

	}

#else /* NTLM SSP */

	nla->status = nla->table->QuerySecurityPackageInfo(NLA_PKG_NAME, &nla->pPackageInfo);

	if (nla->status != SEC_E_OK)

	{

		WLog_ERR(TAG, "QuerySecurityPackageInfo status %s [0x%08" PRIX32 "]",

		         GetSecurityStatusString(nla->status), nla->status);

		return -1;

	}

#endif

	nla->cbMaxToken = nla->pPackageInfo->cbMaxToken;

	nla->packageName = nla->pPackageInfo->Name;

	WLog_DBG(TAG, "%s %" PRIu32 " : packageName=%ls ; cbMaxToken=%d", __FUNCTION__, __LINE__,

	         nla->packageName, nla->cbMaxToken);

	nla->status = nla->table->AcquireCredentialsHandle(NULL, NLA_PKG_NAME, SECPKG_CRED_OUTBOUND,

	                                                   NULL, nla->identity, NULL, NULL,

	                                                   &nla->credentials, &nla->expiration);

	if (nla->status != SEC_E_OK)

	{

		WLog_ERR(TAG, "AcquireCredentialsHandle status %s [0x%08" PRIX32 "]",

		         GetSecurityStatusString(nla->status), nla->status);

		return -1;

	}

	nla->haveContext = FALSE;

	nla->haveInputBuffer = FALSE;

	nla->havePubKeyAuth = FALSE;

	ZeroMemory(&nla->inputBuffer, sizeof(SecBuffer));

	ZeroMemory(&nla->outputBuffer, sizeof(SecBuffer));

	ZeroMemory(&nla->ContextSizes, sizeof(SecPkgContext_Sizes));

	/*

	 * from tspkg.dll: 0x00000132

	 * ISC_REQ_MUTUAL_AUTH

	 * ISC_REQ_CONFIDENTIALITY

	 * ISC_REQ_USE_SESSION_KEY

	 * ISC_REQ_ALLOCATE_MEMORY

	 */

	nla->fContextReq = ISC_REQ_MUTUAL_AUTH | ISC_REQ_CONFIDENTIALITY | ISC_REQ_USE_SESSION_KEY;

	return 1;

}

int nla_client_begin(rdpNla* nla)

{

	if (nla_client_init(nla) < 1)

		return -1;

	if (nla->state != NLA_STATE_INITIAL)

		return -1;

	nla->outputBufferDesc.ulVersion = SECBUFFER_VERSION;

	nla->outputBufferDesc.cBuffers = 1;

	nla->outputBufferDesc.pBuffers = &nla->outputBuffer;

	nla->outputBuffer.BufferType = SECBUFFER_TOKEN;

	nla->outputBuffer.cbBuffer = nla->cbMaxToken;

	nla->outputBuffer.pvBuffer = malloc(nla->outputBuffer.cbBuffer);

	if (!nla->outputBuffer.pvBuffer)

		return -1;

	nla->status = nla->table->InitializeSecurityContext(

	    &nla->credentials, NULL, nla->ServicePrincipalName, nla->fContextReq, 0,

	    SECURITY_NATIVE_DREP, NULL, 0, &nla->context, &nla->outputBufferDesc, &nla->pfContextAttr,

	    &nla->expiration);

	WLog_VRB(TAG, " InitializeSecurityContext status %s [0x%08" PRIX32 "]",

	         GetSecurityStatusString(nla->status), nla->status);

	/* Handle kerberos context initialization failure.

	 * After kerberos failed initialize NTLM context */

	if (nla->status == SEC_E_NO_CREDENTIALS)

	{

		nla->status = nla->table->InitializeSecurityContext(

		    &nla->credentials, NULL, nla->ServicePrincipalName, nla->fContextReq, 0,

		    SECURITY_NATIVE_DREP, NULL, 0, &nla->context, &nla->outputBufferDesc,

		    &nla->pfContextAttr, &nla->expiration);

		WLog_VRB(TAG, " InitializeSecurityContext status %s [0x%08" PRIX32 "]",

		         GetSecurityStatusString(nla->status), nla->status);

		if (nla->status)

		{

			SECURITY_STATUS status =

			    nla->table->QuerySecurityPackageInfo(NTLM_SSP_NAME, &nla->pPackageInfo);

			if (status != SEC_E_OK)

			{

				WLog_ERR(TAG, "QuerySecurityPackageInfo status %s [0x%08" PRIX32 "]",

				         GetSecurityStatusString(nla->status), status);

				return -1;

			}

			nla->cbMaxToken = nla->pPackageInfo->cbMaxToken;

			nla->packageName = nla->pPackageInfo->Name;

		}

	}

	if ((nla->status == SEC_I_COMPLETE_AND_CONTINUE) || (nla->status == SEC_I_COMPLETE_NEEDED))

	{

		if (nla->table->CompleteAuthToken)

		{

			SECURITY_STATUS status;

			status = nla->table->CompleteAuthToken(&nla->context, &nla->outputBufferDesc);

			if (status != SEC_E_OK)

			{

				WLog_WARN(TAG, "CompleteAuthToken status %s [0x%08" PRIX32 "]",

				          GetSecurityStatusString(status), status);

				return -1;

			}

		}

		if (nla->status == SEC_I_COMPLETE_NEEDED)

			nla->status = SEC_E_OK;

		else if (nla->status == SEC_I_COMPLETE_AND_CONTINUE)

			nla->status = SEC_I_CONTINUE_NEEDED;

	}

	if (nla->status != SEC_I_CONTINUE_NEEDED)

		return -1;

	if (nla->outputBuffer.cbBuffer < 1)

		return -1;

	nla->negoToken.pvBuffer = nla->outputBuffer.pvBuffer;

	nla->negoToken.cbBuffer = nla->outputBuffer.cbBuffer;

	WLog_DBG(TAG, "Sending Authentication Token");

#if defined(WITH_DEBUG_NLA)

	winpr_HexDump(TAG, WLOG_DEBUG, nla->negoToken.pvBuffer, nla->negoToken.cbBuffer);

#endif

	if (!nla_send(nla))

	{

		nla_buffer_free(nla);

		return -1;

	}

	nla_buffer_free(nla);

	nla->state = NLA_STATE_NEGO_TOKEN;

	return 1;

}

static int nla_client_recv(rdpNla* nla)

{

	int status = -1;

	if (nla->state == NLA_STATE_NEGO_TOKEN)

	{

		nla->inputBufferDesc.ulVersion = SECBUFFER_VERSION;

		nla->inputBufferDesc.cBuffers = 1;

		nla->inputBufferDesc.pBuffers = &nla->inputBuffer;

		nla->inputBuffer.BufferType = SECBUFFER_TOKEN;

		nla->inputBuffer.pvBuffer = nla->negoToken.pvBuffer;

		nla->inputBuffer.cbBuffer = nla->negoToken.cbBuffer;

		nla->outputBufferDesc.ulVersion = SECBUFFER_VERSION;

		nla->outputBufferDesc.cBuffers = 1;

		nla->outputBufferDesc.pBuffers = &nla->outputBuffer;

		nla->outputBuffer.BufferType = SECBUFFER_TOKEN;

		nla->outputBuffer.cbBuffer = nla->cbMaxToken;

		nla->outputBuffer.pvBuffer = malloc(nla->outputBuffer.cbBuffer);

		if (!nla->outputBuffer.pvBuffer)

			return -1;

		nla->status = nla->table->InitializeSecurityContext(

		    &nla->credentials, &nla->context, nla->ServicePrincipalName, nla->fContextReq, 0,

		    SECURITY_NATIVE_DREP, &nla->inputBufferDesc, 0, &nla->context, &nla->outputBufferDesc,

		    &nla->pfContextAttr, &nla->expiration);

		WLog_VRB(TAG, "InitializeSecurityContext  %s [0x%08" PRIX32 "]",

		         GetSecurityStatusString(nla->status), nla->status);

		free(nla->inputBuffer.pvBuffer);

		nla->inputBuffer.pvBuffer = NULL;

		if ((nla->status == SEC_I_COMPLETE_AND_CONTINUE) || (nla->status == SEC_I_COMPLETE_NEEDED))

		{

			if (nla->table->CompleteAuthToken)

			{

				SECURITY_STATUS status;

				status = nla->table->CompleteAuthToken(&nla->context, &nla->outputBufferDesc);

				if (status != SEC_E_OK)

				{

					WLog_WARN(TAG, "CompleteAuthToken status %s [0x%08" PRIX32 "]",

					          GetSecurityStatusString(status), status);

					return -1;

				}

			}

			if (nla->status == SEC_I_COMPLETE_NEEDED)

				nla->status = SEC_E_OK;

			else if (nla->status == SEC_I_COMPLETE_AND_CONTINUE)

				nla->status = SEC_I_CONTINUE_NEEDED;

		}

		if (nla->status == SEC_E_OK)

		{

			nla->havePubKeyAuth = TRUE;

			nla->status = nla->table->QueryContextAttributes(&nla->context, SECPKG_ATTR_SIZES,

			                                                 &nla->ContextSizes);

			if (nla->status != SEC_E_OK)

			{

				WLog_ERR(TAG,

				         "QueryContextAttributes SECPKG_ATTR_SIZES failure %s [0x%08" PRIX32 "]",

				         GetSecurityStatusString(nla->status), nla->status);

				return -1;

			}

			if (nla->peerVersion < 5)

				nla->status = nla_encrypt_public_key_echo(nla);

			else

				nla->status = nla_encrypt_public_key_hash(nla);

			if (nla->status != SEC_E_OK)

				return -1;

		}

		nla->negoToken.pvBuffer = nla->outputBuffer.pvBuffer;

		nla->negoToken.cbBuffer = nla->outputBuffer.cbBuffer;

		WLog_DBG(TAG, "Sending Authentication Token");

#if defined(WITH_DEBUG_NLA)

		winpr_HexDump(TAG, WLOG_DEBUG, nla->negoToken.pvBuffer, nla->negoToken.cbBuffer);

#endif

		if (!nla_send(nla))

		{

			nla_buffer_free(nla);

			return -1;

		}

		nla_buffer_free(nla);

		if (nla->status == SEC_E_OK)

			nla->state = NLA_STATE_PUB_KEY_AUTH;

		status = 1;

	}

	else if (nla->state == NLA_STATE_PUB_KEY_AUTH)

	{

		/* Verify Server Public Key Echo */

		if (nla->peerVersion < 5)

			nla->status = nla_decrypt_public_key_echo(nla);

		else

			nla->status = nla_decrypt_public_key_hash(nla);

		nla_buffer_free(nla);

		if (nla->status != SEC_E_OK)

		{

			WLog_ERR(TAG, "Could not verify public key echo %s [0x%08" PRIX32 "]",

			         GetSecurityStatusString(nla->status), nla->status);

			return -1;

		}

		/* Send encrypted credentials */

		nla->status = nla_encrypt_ts_credentials(nla);

		if (nla->status != SEC_E_OK)

		{

			WLog_ERR(TAG, "nla_encrypt_ts_credentials status %s [0x%08" PRIX32 "]",

			         GetSecurityStatusString(nla->status), nla->status);

			return -1;

		}

		if (!nla_send(nla))

		{

			nla_buffer_free(nla);

			return -1;

		}

		nla_buffer_free(nla);

		if (SecIsValidHandle(&nla->credentials))

		{

			nla->table->FreeCredentialsHandle(&nla->credentials);

			SecInvalidateHandle(&nla->credentials);

		}

		if (nla->status != SEC_E_OK)

		{

			WLog_ERR(TAG, "FreeCredentialsHandle status %s [0x%08" PRIX32 "]",

			         GetSecurityStatusString(nla->status), nla->status);

		}

		nla->status = nla->table->FreeContextBuffer(nla->pPackageInfo);

		if (nla->status != SEC_E_OK)

		{

			WLog_ERR(TAG, "FreeContextBuffer status %s [0x%08" PRIX32 "]",

			         GetSecurityStatusString(nla->status), nla->status);

		}

		if (nla->status != SEC_E_OK)

			return -1;

		nla->state = NLA_STATE_AUTH_INFO;

		status = 1;

	}

	return status;

}

static int nla_client_authenticate(rdpNla* nla)

{

	wStream* s;

	int status;

	s = Stream_New(NULL, 4096);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return -1;

	}

	if (nla_client_begin(nla) < 1)

	{

		Stream_Free(s, TRUE);

		return -1;

	}

	while (nla->state < NLA_STATE_AUTH_INFO)

	{

		Stream_SetPosition(s, 0);

		status = transport_read_pdu(nla->transport, s);

		if (status < 0)

		{

			WLog_ERR(TAG, "nla_client_authenticate failure");

			Stream_Free(s, TRUE);

			return -1;

		}

		status = nla_recv_pdu(nla, s);

		if (status < 0)

		{

			Stream_Free(s, TRUE);

			return -1;

		}

	}

	Stream_Free(s, TRUE);

	return 1;

}

/**

 * Initialize NTLMSSP authentication module (server).

 * @param credssp

 */

static int nla_server_init(rdpNla* nla)

{

	rdpTls* tls = nla->transport->tls;

	if (!sspi_SecBufferAlloc(&nla->PublicKey, tls->PublicKeyLength))

	{

		WLog_ERR(TAG, "Failed to allocate SecBuffer for public key");

		return -1;

	}

	CopyMemory(nla->PublicKey.pvBuffer, tls->PublicKey, tls->PublicKeyLength);

	if (nla->SspiModule)

	{

		HMODULE hSSPI;

		INIT_SECURITY_INTERFACE pInitSecurityInterface;

		hSSPI = LoadLibrary(nla->SspiModule);

		if (!hSSPI)

		{

			WLog_ERR(TAG, "Failed to load SSPI module: %s", nla->SspiModule);

			return -1;

		}

#ifdef UNICODE

		pInitSecurityInterface =

		    (INIT_SECURITY_INTERFACE)GetProcAddress(hSSPI, "InitSecurityInterfaceW");

#else

		pInitSecurityInterface =

		    (INIT_SECURITY_INTERFACE)GetProcAddress(hSSPI, "InitSecurityInterfaceA");

#endif

		nla->table = pInitSecurityInterface();

	}

	else

	{

		nla->table = InitSecurityInterfaceEx(0);

	}

	nla->status = nla->table->QuerySecurityPackageInfo(NLA_PKG_NAME, &nla->pPackageInfo);

	if (nla->status != SEC_E_OK)

	{

		WLog_ERR(TAG, "QuerySecurityPackageInfo status %s [0x%08" PRIX32 "]",

		         GetSecurityStatusString(nla->status), nla->status);

		return -1;

	}

	nla->cbMaxToken = nla->pPackageInfo->cbMaxToken;

	nla->packageName = nla->pPackageInfo->Name;

	nla->status =

	    nla->table->AcquireCredentialsHandle(NULL, NLA_PKG_NAME, SECPKG_CRED_INBOUND, NULL, NULL,

	                                         NULL, NULL, &nla->credentials, &nla->expiration);

	if (nla->status != SEC_E_OK)

	{

		WLog_ERR(TAG, "AcquireCredentialsHandle status %s [0x%08" PRIX32 "]",

		         GetSecurityStatusString(nla->status), nla->status);

		return -1;

	}

	nla->haveContext = FALSE;

	nla->haveInputBuffer = FALSE;

	nla->havePubKeyAuth = FALSE;

	ZeroMemory(&nla->inputBuffer, sizeof(SecBuffer));

	ZeroMemory(&nla->outputBuffer, sizeof(SecBuffer));

	ZeroMemory(&nla->inputBufferDesc, sizeof(SecBufferDesc));

	ZeroMemory(&nla->outputBufferDesc, sizeof(SecBufferDesc));

	ZeroMemory(&nla->ContextSizes, sizeof(SecPkgContext_Sizes));

	/*

	 * from tspkg.dll: 0x00000112

	 * ASC_REQ_MUTUAL_AUTH

	 * ASC_REQ_CONFIDENTIALITY

	 * ASC_REQ_ALLOCATE_MEMORY

	 */

	nla->fContextReq = 0;

	nla->fContextReq |= ASC_REQ_MUTUAL_AUTH;

	nla->fContextReq |= ASC_REQ_CONFIDENTIALITY;

	nla->fContextReq |= ASC_REQ_CONNECTION;

	nla->fContextReq |= ASC_REQ_USE_SESSION_KEY;

	nla->fContextReq |= ASC_REQ_REPLAY_DETECT;

	nla->fContextReq |= ASC_REQ_SEQUENCE_DETECT;

	nla->fContextReq |= ASC_REQ_EXTENDED_ERROR;

	return 1;

}

/**

 * Authenticate with client using CredSSP (server).

 * @param credssp

 * @return 1 if authentication is successful

 */

static int nla_server_authenticate(rdpNla* nla)

{

	if (nla_server_init(nla) < 1)

		return -1;

	while (TRUE)

	{

		/* receive authentication token */

		nla->inputBufferDesc.ulVersion = SECBUFFER_VERSION;

		nla->inputBufferDesc.cBuffers = 1;

		nla->inputBufferDesc.pBuffers = &nla->inputBuffer;

		nla->inputBuffer.BufferType = SECBUFFER_TOKEN;

		if (nla_recv(nla) < 0)

			return -1;

		WLog_DBG(TAG, "Receiving Authentication Token");

		nla_buffer_print(nla);

		nla->inputBuffer.pvBuffer = nla->negoToken.pvBuffer;

		nla->inputBuffer.cbBuffer = nla->negoToken.cbBuffer;

		if (nla->negoToken.cbBuffer < 1)

		{

			WLog_ERR(TAG, "CredSSP: invalid negoToken!");

			return -1;

		}

		nla->outputBufferDesc.ulVersion = SECBUFFER_VERSION;

		nla->outputBufferDesc.cBuffers = 1;

		nla->outputBufferDesc.pBuffers = &nla->outputBuffer;

		nla->outputBuffer.BufferType = SECBUFFER_TOKEN;

		nla->outputBuffer.cbBuffer = nla->cbMaxToken;

		nla->outputBuffer.pvBuffer = malloc(nla->outputBuffer.cbBuffer);

		if (!nla->outputBuffer.pvBuffer)

			return -1;

		nla->status = nla->table->AcceptSecurityContext(

		    &nla->credentials, nla->haveContext ? &nla->context : NULL, &nla->inputBufferDesc,

		    nla->fContextReq, SECURITY_NATIVE_DREP, &nla->context, &nla->outputBufferDesc,

		    &nla->pfContextAttr, &nla->expiration);

		WLog_VRB(TAG, "AcceptSecurityContext status %s [0x%08" PRIX32 "]",

		         GetSecurityStatusString(nla->status), nla->status);