/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Security Support Provider Interface (SSPI)

 *

 * Copyright 2012-2014 Marc-Andre Moreau <marcandre.moreau@gmail.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 <winpr/windows.h>

#include <winpr/crt.h>

#include <winpr/sspi.h>

#include <winpr/ssl.h>

#include <winpr/print.h>

#include "sspi.h"

#include "sspi_winpr.h"

#include "../log.h"

#define TAG WINPR_TAG("sspi")

/* Authentication Functions: http://msdn.microsoft.com/en-us/library/windows/desktop/aa374731/ */

extern const SecPkgInfoA NTLM_SecPkgInfoA;

extern const SecPkgInfoW NTLM_SecPkgInfoW;

extern const SecurityFunctionTableA NTLM_SecurityFunctionTableA;

extern const SecurityFunctionTableW NTLM_SecurityFunctionTableW;

extern const SecPkgInfoA KERBEROS_SecPkgInfoA;

extern const SecPkgInfoW KERBEROS_SecPkgInfoW;

extern const SecurityFunctionTableA KERBEROS_SecurityFunctionTableA;

extern const SecurityFunctionTableW KERBEROS_SecurityFunctionTableW;

extern const SecPkgInfoA NEGOTIATE_SecPkgInfoA;

extern const SecPkgInfoW NEGOTIATE_SecPkgInfoW;

extern const SecurityFunctionTableA NEGOTIATE_SecurityFunctionTableA;

extern const SecurityFunctionTableW NEGOTIATE_SecurityFunctionTableW;

extern const SecPkgInfoA CREDSSP_SecPkgInfoA;

extern const SecPkgInfoW CREDSSP_SecPkgInfoW;

extern const SecurityFunctionTableA CREDSSP_SecurityFunctionTableA;

extern const SecurityFunctionTableW CREDSSP_SecurityFunctionTableW;

extern const SecPkgInfoA SCHANNEL_SecPkgInfoA;

extern const SecPkgInfoW SCHANNEL_SecPkgInfoW;

extern const SecurityFunctionTableA SCHANNEL_SecurityFunctionTableA;

extern const SecurityFunctionTableW SCHANNEL_SecurityFunctionTableW;

static const SecPkgInfoA* SecPkgInfoA_LIST[] = { &NTLM_SecPkgInfoA, &KERBEROS_SecPkgInfoA,

	                                             &NEGOTIATE_SecPkgInfoA, &CREDSSP_SecPkgInfoA,

	                                             &SCHANNEL_SecPkgInfoA };

static const SecPkgInfoW* SecPkgInfoW_LIST[] = { &NTLM_SecPkgInfoW, &KERBEROS_SecPkgInfoW,

	                                             &NEGOTIATE_SecPkgInfoW, &CREDSSP_SecPkgInfoW,

	                                             &SCHANNEL_SecPkgInfoW };

static SecurityFunctionTableA winpr_SecurityFunctionTableA;

static SecurityFunctionTableW winpr_SecurityFunctionTableW;

struct _SecurityFunctionTableA_NAME

{

	const SEC_CHAR* Name;

	const SecurityFunctionTableA* SecurityFunctionTable;

};

typedef struct _SecurityFunctionTableA_NAME SecurityFunctionTableA_NAME;

struct _SecurityFunctionTableW_NAME

{

	const SEC_WCHAR* Name;

	const SecurityFunctionTableW* SecurityFunctionTable;

};

typedef struct _SecurityFunctionTableW_NAME SecurityFunctionTableW_NAME;

static const SecurityFunctionTableA_NAME SecurityFunctionTableA_NAME_LIST[] = {

	{ "NTLM", &NTLM_SecurityFunctionTableA },

	{ "Kerberos", &KERBEROS_SecurityFunctionTableA },

	{ "Negotiate", &NEGOTIATE_SecurityFunctionTableA },

	{ "CREDSSP", &CREDSSP_SecurityFunctionTableA },

	{ "Schannel", &SCHANNEL_SecurityFunctionTableA }

};

static const WCHAR NTLM_NAME_W[] = { 'N', 'T', 'L', 'M', '\0' };

static const WCHAR KERBEROS_NAME_W[] = { 'K', 'e', 'r', 'b', 'e', 'r', 'o', 's', '\0' };

static const WCHAR NEGOTIATE_NAME_W[] = { 'N', 'e', 'g', 'o', 't', 'i', 'a', 't', 'e', '\0' };

static const WCHAR CREDSSP_NAME_W[] = { 'C', 'r', 'e', 'd', 'S', 'S', 'P', '\0' };

static const WCHAR SCHANNEL_NAME_W[] = { 'S', 'c', 'h', 'a', 'n', 'n', 'e', 'l', '\0' };

static const SecurityFunctionTableW_NAME SecurityFunctionTableW_NAME_LIST[] = {

	{ NTLM_NAME_W, &NTLM_SecurityFunctionTableW },

	{ KERBEROS_NAME_W, &KERBEROS_SecurityFunctionTableW },

	{ NEGOTIATE_NAME_W, &NEGOTIATE_SecurityFunctionTableW },

	{ CREDSSP_NAME_W, &CREDSSP_SecurityFunctionTableW },

	{ SCHANNEL_NAME_W, &SCHANNEL_SecurityFunctionTableW }

};

#define SecHandle_LOWER_MAX 0xFFFFFFFF

#define SecHandle_UPPER_MAX 0xFFFFFFFE

struct _CONTEXT_BUFFER_ALLOC_ENTRY

{

	void* contextBuffer;

	UINT32 allocatorIndex;

};

typedef struct _CONTEXT_BUFFER_ALLOC_ENTRY CONTEXT_BUFFER_ALLOC_ENTRY;

struct _CONTEXT_BUFFER_ALLOC_TABLE

{

	UINT32 cEntries;

	UINT32 cMaxEntries;

	CONTEXT_BUFFER_ALLOC_ENTRY* entries;

};

typedef struct _CONTEXT_BUFFER_ALLOC_TABLE CONTEXT_BUFFER_ALLOC_TABLE;

static CONTEXT_BUFFER_ALLOC_TABLE ContextBufferAllocTable = { 0 };

static int sspi_ContextBufferAllocTableNew(void)

{

	size_t size;

	ContextBufferAllocTable.entries = NULL;

	ContextBufferAllocTable.cEntries = 0;

	ContextBufferAllocTable.cMaxEntries = 4;

	size = sizeof(CONTEXT_BUFFER_ALLOC_ENTRY) * ContextBufferAllocTable.cMaxEntries;

	ContextBufferAllocTable.entries = (CONTEXT_BUFFER_ALLOC_ENTRY*)calloc(1, size);

	if (!ContextBufferAllocTable.entries)

		return -1;

	return 1;

}

static int sspi_ContextBufferAllocTableGrow(void)

{

	size_t size;

	CONTEXT_BUFFER_ALLOC_ENTRY* entries;

	ContextBufferAllocTable.cEntries = 0;

	ContextBufferAllocTable.cMaxEntries *= 2;

	size = sizeof(CONTEXT_BUFFER_ALLOC_ENTRY) * ContextBufferAllocTable.cMaxEntries;

	if (!size)

		return -1;

	entries = (CONTEXT_BUFFER_ALLOC_ENTRY*)realloc(ContextBufferAllocTable.entries, size);

	if (!entries)

	{

		free(ContextBufferAllocTable.entries);

		return -1;

	}

	ContextBufferAllocTable.entries = entries;

	ZeroMemory((void*)&ContextBufferAllocTable.entries[ContextBufferAllocTable.cMaxEntries / 2],

	           size / 2);

	return 1;

}

static void sspi_ContextBufferAllocTableFree(void)

{

	if (ContextBufferAllocTable.cEntries != 0)

		WLog_ERR(TAG, "ContextBufferAllocTable.entries == %" PRIu32,

		         ContextBufferAllocTable.cEntries);

	ContextBufferAllocTable.cEntries = ContextBufferAllocTable.cMaxEntries = 0;

	free(ContextBufferAllocTable.entries);

	ContextBufferAllocTable.entries = NULL;

}

static void* sspi_ContextBufferAlloc(UINT32 allocatorIndex, size_t size)

{

	UINT32 index;

	void* contextBuffer;

	for (index = 0; index < ContextBufferAllocTable.cMaxEntries; index++)

	{

		if (!ContextBufferAllocTable.entries[index].contextBuffer)

		{

			contextBuffer = calloc(1, size);

			if (!contextBuffer)

				return NULL;

			ContextBufferAllocTable.cEntries++;

			ContextBufferAllocTable.entries[index].contextBuffer = contextBuffer;

			ContextBufferAllocTable.entries[index].allocatorIndex = allocatorIndex;

			return ContextBufferAllocTable.entries[index].contextBuffer;

		}

	}

	/* no available entry was found, the table needs to be grown */

	if (sspi_ContextBufferAllocTableGrow() < 0)

		return NULL;

	/* the next call to sspi_ContextBufferAlloc() should now succeed */

	return sspi_ContextBufferAlloc(allocatorIndex, size);

}

SSPI_CREDENTIALS* sspi_CredentialsNew(void)

{

	SSPI_CREDENTIALS* credentials;

	credentials = (SSPI_CREDENTIALS*)calloc(1, sizeof(SSPI_CREDENTIALS));

	return credentials;

}

void sspi_CredentialsFree(SSPI_CREDENTIALS* credentials)

{

	size_t userLength = 0;

	size_t domainLength = 0;

	size_t passwordLength = 0;

	if (!credentials)

		return;

	userLength = credentials->identity.UserLength;

	domainLength = credentials->identity.DomainLength;

	passwordLength = credentials->identity.PasswordLength;

	if (passwordLength > SSPI_CREDENTIALS_HASH_LENGTH_OFFSET) /* [pth] */

		passwordLength -= SSPI_CREDENTIALS_HASH_LENGTH_OFFSET;

	if (credentials->identity.Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE)

	{

		userLength *= 2;

		domainLength *= 2;

		passwordLength *= 2;

	}

	if (credentials->identity.User)

		memset(credentials->identity.User, 0, userLength);

	if (credentials->identity.Domain)

		memset(credentials->identity.Domain, 0, domainLength);

	if (credentials->identity.Password)

		memset(credentials->identity.Password, 0, passwordLength);

	free(credentials->identity.User);

	free(credentials->identity.Domain);

	free(credentials->identity.Password);

	free(credentials);

}

void* sspi_SecBufferAlloc(PSecBuffer SecBuffer, ULONG size)

{

	if (!SecBuffer)

		return NULL;

	SecBuffer->pvBuffer = calloc(1, size);

	if (!SecBuffer->pvBuffer)

		return NULL;

	SecBuffer->cbBuffer = size;

	return SecBuffer->pvBuffer;

}

void sspi_SecBufferFree(PSecBuffer SecBuffer)

{

	if (!SecBuffer)

		return;

	if (SecBuffer->pvBuffer)

		memset(SecBuffer->pvBuffer, 0, SecBuffer->cbBuffer);

	free(SecBuffer->pvBuffer);

	SecBuffer->pvBuffer = NULL;

	SecBuffer->cbBuffer = 0;

}

SecHandle* sspi_SecureHandleAlloc(void)

{

	SecHandle* handle = (SecHandle*)calloc(1, sizeof(SecHandle));

	if (!handle)

		return NULL;

	SecInvalidateHandle(handle);

	return handle;

}

void* sspi_SecureHandleGetLowerPointer(SecHandle* handle)

{

	void* pointer;

	if (!handle || !SecIsValidHandle(handle) || !handle->dwLower)

		return NULL;

	pointer = (void*)~((size_t)handle->dwLower);

	return pointer;

}

void sspi_SecureHandleInvalidate(SecHandle* handle)

{

	if (!handle)

		return;

	handle->dwLower = 0;

	handle->dwUpper = 0;

}

void sspi_SecureHandleSetLowerPointer(SecHandle* handle, void* pointer)

{

	if (!handle)

		return;

	handle->dwLower = (ULONG_PTR)(~((size_t)pointer));

}

void* sspi_SecureHandleGetUpperPointer(SecHandle* handle)

{

	void* pointer;

	if (!handle || !SecIsValidHandle(handle) || !handle->dwUpper)

		return NULL;

	pointer = (void*)~((size_t)handle->dwUpper);

	return pointer;

}

void sspi_SecureHandleSetUpperPointer(SecHandle* handle, void* pointer)

{

	if (!handle)

		return;

	handle->dwUpper = (ULONG_PTR)(~((size_t)pointer));

}

void sspi_SecureHandleFree(SecHandle* handle)

{

	free(handle);

}

int sspi_SetAuthIdentity(SEC_WINNT_AUTH_IDENTITY* identity, const char* user, const char* domain,

                         const char* password)

{

	int rc;

	int unicodePasswordLenW;

	LPWSTR unicodePassword = NULL;

	unicodePasswordLenW = ConvertToUnicode(CP_UTF8, 0, password, -1, &unicodePassword, 0);

	if (unicodePasswordLenW <= 0)

		return -1;

	rc = sspi_SetAuthIdentityWithUnicodePassword(identity, user, domain, unicodePassword,

	                                             (ULONG)(unicodePasswordLenW - 1));

	free(unicodePassword);

	return rc;

}

int sspi_SetAuthIdentityWithUnicodePassword(SEC_WINNT_AUTH_IDENTITY* identity, const char* user,

                                            const char* domain, LPWSTR password,

                                            ULONG passwordLength)

{

	int status;

	identity->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;

	free(identity->User);

	identity->User = (UINT16*)NULL;

	identity->UserLength = 0;

	if (user)

	{

		status = ConvertToUnicode(CP_UTF8, 0, user, -1, (LPWSTR*)&(identity->User), 0);

		if (status <= 0)

			return -1;

		identity->UserLength = (ULONG)(status - 1);

	}

	free(identity->Domain);

	identity->Domain = (UINT16*)NULL;

	identity->DomainLength = 0;

	if (domain)

	{

		status = ConvertToUnicode(CP_UTF8, 0, domain, -1, (LPWSTR*)&(identity->Domain), 0);

		if (status <= 0)

			return -1;

		identity->DomainLength = (ULONG)(status - 1);

	}

	free(identity->Password);

	identity->Password = (UINT16*)calloc(1, (passwordLength + 1) * sizeof(WCHAR));

	if (!identity->Password)

		return -1;

	CopyMemory(identity->Password, password, passwordLength * sizeof(WCHAR));

	identity->PasswordLength = passwordLength;

	return 1;

}

int sspi_CopyAuthIdentity(SEC_WINNT_AUTH_IDENTITY* identity, SEC_WINNT_AUTH_IDENTITY* srcIdentity)

{

	int status;

	if (srcIdentity->Flags & SEC_WINNT_AUTH_IDENTITY_ANSI)

	{

		status = sspi_SetAuthIdentity(identity, (char*)srcIdentity->User,

		                              (char*)srcIdentity->Domain, (char*)srcIdentity->Password);

		if (status <= 0)

			return -1;

		identity->Flags &= ~SEC_WINNT_AUTH_IDENTITY_ANSI;

		identity->Flags |= SEC_WINNT_AUTH_IDENTITY_UNICODE;

		return 1;

	}

	identity->Flags |= SEC_WINNT_AUTH_IDENTITY_UNICODE;

	/* login/password authentication */

	identity->User = identity->Domain = identity->Password = NULL;

	identity->UserLength = srcIdentity->UserLength;

	if (identity->UserLength > 0)

	{

		identity->User = (UINT16*)calloc((identity->UserLength + 1), sizeof(WCHAR));

		if (!identity->User)

			return -1;

		CopyMemory(identity->User, srcIdentity->User, identity->UserLength * sizeof(WCHAR));

		identity->User[identity->UserLength] = 0;

	}

	identity->DomainLength = srcIdentity->DomainLength;

	if (identity->DomainLength > 0)

	{

		identity->Domain = (UINT16*)calloc((identity->DomainLength + 1), sizeof(WCHAR));

		if (!identity->Domain)

			return -1;

		CopyMemory(identity->Domain, srcIdentity->Domain, identity->DomainLength * sizeof(WCHAR));

		identity->Domain[identity->DomainLength] = 0;

	}

	identity->PasswordLength = srcIdentity->PasswordLength;

	if (identity->PasswordLength > SSPI_CREDENTIALS_HASH_LENGTH_OFFSET)

		identity->PasswordLength -= SSPI_CREDENTIALS_HASH_LENGTH_OFFSET;

	if (srcIdentity->Password)

	{

		identity->Password = (UINT16*)calloc((identity->PasswordLength + 1), sizeof(WCHAR));

		if (!identity->Password)

			return -1;

		CopyMemory(identity->Password, srcIdentity->Password,

		           identity->PasswordLength * sizeof(WCHAR));

		identity->Password[identity->PasswordLength] = 0;

	}

	identity->PasswordLength = srcIdentity->PasswordLength;

	/* End of login/password authentication */

	return 1;

}

PSecBuffer sspi_FindSecBuffer(PSecBufferDesc pMessage, ULONG BufferType)

{

	ULONG index;

	PSecBuffer pSecBuffer = NULL;

	for (index = 0; index < pMessage->cBuffers; index++)

	{

		if (pMessage->pBuffers[index].BufferType == BufferType)

		{

			pSecBuffer = &pMessage->pBuffers[index];

			break;

		}

	}

	return pSecBuffer;

}

static BOOL CALLBACK sspi_init(PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context)

{

	winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);

	sspi_ContextBufferAllocTableNew();

	return TRUE;

}

void sspi_GlobalInit(void)

{

	static INIT_ONCE once = INIT_ONCE_STATIC_INIT;

	DWORD flags = 0;

	InitOnceExecuteOnce(&once, sspi_init, &flags, NULL);

}

void sspi_GlobalFinish(void)

{

	sspi_ContextBufferAllocTableFree();

}

static SecurityFunctionTableA* sspi_GetSecurityFunctionTableAByNameA(const SEC_CHAR* Name)

{

	int index;

	UINT32 cPackages;

	cPackages = sizeof(SecPkgInfoA_LIST) / sizeof(*(SecPkgInfoA_LIST));

	for (index = 0; index < (int)cPackages; index++)

	{

		if (strcmp(Name, SecurityFunctionTableA_NAME_LIST[index].Name) == 0)

		{

			return (SecurityFunctionTableA*)SecurityFunctionTableA_NAME_LIST[index]

			    .SecurityFunctionTable;

		}

	}

	return NULL;

}

static SecurityFunctionTableW* sspi_GetSecurityFunctionTableWByNameW(const SEC_WCHAR* Name)

{

	int index;

	UINT32 cPackages;

	cPackages = sizeof(SecPkgInfoW_LIST) / sizeof(*(SecPkgInfoW_LIST));

	for (index = 0; index < (int)cPackages; index++)

	{

		if (lstrcmpW(Name, SecurityFunctionTableW_NAME_LIST[index].Name) == 0)

		{

			return (SecurityFunctionTableW*)SecurityFunctionTableW_NAME_LIST[index]

			    .SecurityFunctionTable;

		}

	}

	return NULL;

}

static SecurityFunctionTableW* sspi_GetSecurityFunctionTableWByNameA(const SEC_CHAR* Name)

{

	int status;

	SEC_WCHAR* NameW = NULL;

	SecurityFunctionTableW* table;

	status = ConvertToUnicode(CP_UTF8, 0, Name, -1, &NameW, 0);

	if (status <= 0)

		return NULL;

	table = sspi_GetSecurityFunctionTableWByNameW(NameW);

	free(NameW);

	return table;

}

static void FreeContextBuffer_EnumerateSecurityPackages(void* contextBuffer);

static void FreeContextBuffer_QuerySecurityPackageInfo(void* contextBuffer);

static void sspi_ContextBufferFree(void* contextBuffer)

{

	UINT32 index;

	UINT32 allocatorIndex;

	for (index = 0; index < ContextBufferAllocTable.cMaxEntries; index++)

	{

		if (contextBuffer == ContextBufferAllocTable.entries[index].contextBuffer)

		{

			contextBuffer = ContextBufferAllocTable.entries[index].contextBuffer;

			allocatorIndex = ContextBufferAllocTable.entries[index].allocatorIndex;

			ContextBufferAllocTable.cEntries--;

			ContextBufferAllocTable.entries[index].allocatorIndex = 0;

			ContextBufferAllocTable.entries[index].contextBuffer = NULL;

			switch (allocatorIndex)

			{

				case EnumerateSecurityPackagesIndex:

					FreeContextBuffer_EnumerateSecurityPackages(contextBuffer);

					break;

				case QuerySecurityPackageInfoIndex:

					FreeContextBuffer_QuerySecurityPackageInfo(contextBuffer);

					break;

			}

		}

	}

}

/**

 * Standard SSPI API

 */

/* Package Management */

static SECURITY_STATUS SEC_ENTRY winpr_EnumerateSecurityPackagesW(ULONG* pcPackages,

                                                                  PSecPkgInfoW* ppPackageInfo)

{

	int index;

	size_t size;

	UINT32 cPackages;

	SecPkgInfoW* pPackageInfo;

	cPackages = sizeof(SecPkgInfoW_LIST) / sizeof(*(SecPkgInfoW_LIST));

	size = sizeof(SecPkgInfoW) * cPackages;

	pPackageInfo = (SecPkgInfoW*)sspi_ContextBufferAlloc(EnumerateSecurityPackagesIndex, size);

	if (!pPackageInfo)

		return SEC_E_INSUFFICIENT_MEMORY;

	for (index = 0; index < (int)cPackages; index++)

	{

		pPackageInfo[index].fCapabilities = SecPkgInfoW_LIST[index]->fCapabilities;

		pPackageInfo[index].wVersion = SecPkgInfoW_LIST[index]->wVersion;

		pPackageInfo[index].wRPCID = SecPkgInfoW_LIST[index]->wRPCID;

		pPackageInfo[index].cbMaxToken = SecPkgInfoW_LIST[index]->cbMaxToken;

		pPackageInfo[index].Name = _wcsdup(SecPkgInfoW_LIST[index]->Name);

		pPackageInfo[index].Comment = _wcsdup(SecPkgInfoW_LIST[index]->Comment);

	}

	*(pcPackages) = cPackages;

	*(ppPackageInfo) = pPackageInfo;

	return SEC_E_OK;

}

static SECURITY_STATUS SEC_ENTRY winpr_EnumerateSecurityPackagesA(ULONG* pcPackages,

                                                                  PSecPkgInfoA* ppPackageInfo)

{

	int index;

	size_t size;

	UINT32 cPackages;

	SecPkgInfoA* pPackageInfo;

	cPackages = sizeof(SecPkgInfoA_LIST) / sizeof(*(SecPkgInfoA_LIST));

	size = sizeof(SecPkgInfoA) * cPackages;

	pPackageInfo = (SecPkgInfoA*)sspi_ContextBufferAlloc(EnumerateSecurityPackagesIndex, size);

	if (!pPackageInfo)

		return SEC_E_INSUFFICIENT_MEMORY;

	for (index = 0; index < (int)cPackages; index++)

	{

		pPackageInfo[index].fCapabilities = SecPkgInfoA_LIST[index]->fCapabilities;

		pPackageInfo[index].wVersion = SecPkgInfoA_LIST[index]->wVersion;

		pPackageInfo[index].wRPCID = SecPkgInfoA_LIST[index]->wRPCID;

		pPackageInfo[index].cbMaxToken = SecPkgInfoA_LIST[index]->cbMaxToken;

		pPackageInfo[index].Name = _strdup(SecPkgInfoA_LIST[index]->Name);

		pPackageInfo[index].Comment = _strdup(SecPkgInfoA_LIST[index]->Comment);

		if (!pPackageInfo[index].Name || !pPackageInfo[index].Comment)

		{

			sspi_ContextBufferFree(pPackageInfo);

			return SEC_E_INSUFFICIENT_MEMORY;

		}

	}

	*(pcPackages) = cPackages;

	*(ppPackageInfo) = pPackageInfo;

	return SEC_E_OK;

}

static void FreeContextBuffer_EnumerateSecurityPackages(void* contextBuffer)

{

	int index;

	UINT32 cPackages;

	SecPkgInfoA* pPackageInfo = (SecPkgInfoA*)contextBuffer;

	cPackages = sizeof(SecPkgInfoA_LIST) / sizeof(*(SecPkgInfoA_LIST));

	if (!pPackageInfo)

		return;

	for (index = 0; index < (int)cPackages; index++)

	{

		free(pPackageInfo[index].Name);

		free(pPackageInfo[index].Comment);

	}

	free(pPackageInfo);

}

SecurityFunctionTableW* SEC_ENTRY winpr_InitSecurityInterfaceW(void)

{

	return &winpr_SecurityFunctionTableW;

}

SecurityFunctionTableA* SEC_ENTRY winpr_InitSecurityInterfaceA(void)

{

	return &winpr_SecurityFunctionTableA;

}

static SECURITY_STATUS SEC_ENTRY winpr_QuerySecurityPackageInfoW(SEC_WCHAR* pszPackageName,

                                                                 PSecPkgInfoW* ppPackageInfo)

{

	int index;

	size_t size;

	UINT32 cPackages;

	SecPkgInfoW* pPackageInfo;

	cPackages = sizeof(SecPkgInfoW_LIST) / sizeof(*(SecPkgInfoW_LIST));

	for (index = 0; index < (int)cPackages; index++)

	{

		if (lstrcmpW(pszPackageName, SecPkgInfoW_LIST[index]->Name) == 0)

		{

			size = sizeof(SecPkgInfoW);

			pPackageInfo =

			    (SecPkgInfoW*)sspi_ContextBufferAlloc(QuerySecurityPackageInfoIndex, size);

			if (!pPackageInfo)

				return SEC_E_INSUFFICIENT_MEMORY;

			pPackageInfo->fCapabilities = SecPkgInfoW_LIST[index]->fCapabilities;

			pPackageInfo->wVersion = SecPkgInfoW_LIST[index]->wVersion;

			pPackageInfo->wRPCID = SecPkgInfoW_LIST[index]->wRPCID;

			pPackageInfo->cbMaxToken = SecPkgInfoW_LIST[index]->cbMaxToken;

			pPackageInfo->Name = _wcsdup(SecPkgInfoW_LIST[index]->Name);

			pPackageInfo->Comment = _wcsdup(SecPkgInfoW_LIST[index]->Comment);

			*(ppPackageInfo) = pPackageInfo;

			return SEC_E_OK;

		}

	}

	*(ppPackageInfo) = NULL;

	return SEC_E_SECPKG_NOT_FOUND;

}

static SECURITY_STATUS SEC_ENTRY winpr_QuerySecurityPackageInfoA(SEC_CHAR* pszPackageName,

                                                                 PSecPkgInfoA* ppPackageInfo)

{

	int index;

	size_t size;

	UINT32 cPackages;

	SecPkgInfoA* pPackageInfo;

	cPackages = sizeof(SecPkgInfoA_LIST) / sizeof(*(SecPkgInfoA_LIST));

	for (index = 0; index < (int)cPackages; index++)

	{

		if (strcmp(pszPackageName, SecPkgInfoA_LIST[index]->Name) == 0)

		{

			size = sizeof(SecPkgInfoA);

			pPackageInfo =

			    (SecPkgInfoA*)sspi_ContextBufferAlloc(QuerySecurityPackageInfoIndex, size);

			if (!pPackageInfo)

				return SEC_E_INSUFFICIENT_MEMORY;

			pPackageInfo->fCapabilities = SecPkgInfoA_LIST[index]->fCapabilities;

			pPackageInfo->wVersion = SecPkgInfoA_LIST[index]->wVersion;

			pPackageInfo->wRPCID = SecPkgInfoA_LIST[index]->wRPCID;

			pPackageInfo->cbMaxToken = SecPkgInfoA_LIST[index]->cbMaxToken;

			pPackageInfo->Name = _strdup(SecPkgInfoA_LIST[index]->Name);

			pPackageInfo->Comment = _strdup(SecPkgInfoA_LIST[index]->Comment);

			if (!pPackageInfo->Name || !pPackageInfo->Comment)

			{

				sspi_ContextBufferFree(pPackageInfo);

				return SEC_E_INSUFFICIENT_MEMORY;

			}

			*(ppPackageInfo) = pPackageInfo;

			return SEC_E_OK;

		}

	}

	*(ppPackageInfo) = NULL;

	return SEC_E_SECPKG_NOT_FOUND;

}

void FreeContextBuffer_QuerySecurityPackageInfo(void* contextBuffer)

{

	SecPkgInfo* pPackageInfo = (SecPkgInfo*)contextBuffer;

	if (!pPackageInfo)

		return;

	free(pPackageInfo->Name);

	free(pPackageInfo->Comment);

	free(pPackageInfo);

}

/* Credential Management */

static SECURITY_STATUS SEC_ENTRY winpr_AcquireCredentialsHandleW(

    SEC_WCHAR* pszPrincipal, SEC_WCHAR* pszPackage, ULONG fCredentialUse, void* pvLogonID,

    void* pAuthData, SEC_GET_KEY_FN pGetKeyFn, void* pvGetKeyArgument, PCredHandle phCredential,

    PTimeStamp ptsExpiry)

{

	SECURITY_STATUS status;

	SecurityFunctionTableW* table = sspi_GetSecurityFunctionTableWByNameW(pszPackage);

	if (!table)

		return SEC_E_SECPKG_NOT_FOUND;

	if (!table->AcquireCredentialsHandleW)

		return SEC_E_UNSUPPORTED_FUNCTION;

	status = table->AcquireCredentialsHandleW(pszPrincipal, pszPackage, fCredentialUse, pvLogonID,

	                                          pAuthData, pGetKeyFn, pvGetKeyArgument, phCredential,

	                                          ptsExpiry);

	if (IsSecurityStatusError(status))

	{

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

		          GetSecurityStatusString(status), status);

	}

	return status;

}

static SECURITY_STATUS SEC_ENTRY winpr_AcquireCredentialsHandleA(

    SEC_CHAR* pszPrincipal, SEC_CHAR* pszPackage, ULONG fCredentialUse, void* pvLogonID,

    void* pAuthData, SEC_GET_KEY_FN pGetKeyFn, void* pvGetKeyArgument, PCredHandle phCredential,

    PTimeStamp ptsExpiry)

{

	SECURITY_STATUS status;

	SecurityFunctionTableA* table = sspi_GetSecurityFunctionTableAByNameA(pszPackage);

	if (!table)

		return SEC_E_SECPKG_NOT_FOUND;

	if (!table->AcquireCredentialsHandleA)

		return SEC_E_UNSUPPORTED_FUNCTION;

	status = table->AcquireCredentialsHandleA(pszPrincipal, pszPackage, fCredentialUse, pvLogonID,

	                                          pAuthData, pGetKeyFn, pvGetKeyArgument, phCredential,

	                                          ptsExpiry);

	if (IsSecurityStatusError(status))

	{

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

		          GetSecurityStatusString(status), status);

	}

	return status;

}

static SECURITY_STATUS SEC_ENTRY winpr_ExportSecurityContext(PCtxtHandle phContext, ULONG fFlags,

                                                             PSecBuffer pPackedContext,

                                                             HANDLE* pToken)

{

	SEC_CHAR* Name;

	SECURITY_STATUS status;

	SecurityFunctionTableW* table;

	Name = (SEC_CHAR*)sspi_SecureHandleGetUpperPointer(phContext);

	if (!Name)

		return SEC_E_SECPKG_NOT_FOUND;

	table = sspi_GetSecurityFunctionTableWByNameA(Name);

	if (!table)

		return SEC_E_SECPKG_NOT_FOUND;

	if (!table->ExportSecurityContext)

		return SEC_E_UNSUPPORTED_FUNCTION;

	status = table->ExportSecurityContext(phContext, fFlags, pPackedContext, pToken);

	if (IsSecurityStatusError(status))

	{

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

		          GetSecurityStatusString(status), status);

	}

	return status;

}

static SECURITY_STATUS SEC_ENTRY winpr_FreeCredentialsHandle(PCredHandle phCredential)

{

	char* Name;

	SECURITY_STATUS status;

	SecurityFunctionTableA* table;

	Name = (char*)sspi_SecureHandleGetUpperPointer(phCredential);

	if (!Name)

		return SEC_E_SECPKG_NOT_FOUND;