/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * RDP Licensing

 *

 * Copyright 2011-2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2014 Norbert Federa <norbert.federa@thincast.com>

 * Copyright 2018 David Fort <contact@hardening-consulting.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/crt.h>

#include <winpr/crypto.h>

#include <winpr/shell.h>

#include <winpr/path.h>

#include <freerdp/log.h>

#include "redirection.h"

#include "certificate.h"

#include "license.h"

#define TAG FREERDP_TAG("core.license")

#if 0

#define LICENSE_NULL_CLIENT_RANDOM 1

#define LICENSE_NULL_PREMASTER_SECRET 1

#endif

static wStream* license_send_stream_init(rdpLicense* license);

static void license_generate_randoms(rdpLicense* license);

static BOOL license_generate_keys(rdpLicense* license);

static BOOL license_generate_hwid(rdpLicense* license);

static BOOL license_encrypt_premaster_secret(rdpLicense* license);

static LICENSE_PRODUCT_INFO* license_new_product_info(void);

static void license_free_product_info(LICENSE_PRODUCT_INFO* productInfo);

static BOOL license_read_product_info(wStream* s, LICENSE_PRODUCT_INFO* productInfo);

static LICENSE_BLOB* license_new_binary_blob(UINT16 type);

static void license_free_binary_blob(LICENSE_BLOB* blob);

static BOOL license_read_binary_blob(wStream* s, LICENSE_BLOB* blob);

static BOOL license_write_binary_blob(wStream* s, const LICENSE_BLOB* blob);

static SCOPE_LIST* license_new_scope_list(void);

static void license_free_scope_list(SCOPE_LIST* scopeList);

static BOOL license_read_scope_list(wStream* s, SCOPE_LIST* scopeList);

static BOOL license_read_license_request_packet(rdpLicense* license, wStream* s);

static BOOL license_read_platform_challenge_packet(rdpLicense* license, wStream* s);

static BOOL license_read_new_or_upgrade_license_packet(rdpLicense* license, wStream* s);

static BOOL license_read_error_alert_packet(rdpLicense* license, wStream* s);

static BOOL license_write_new_license_request_packet(rdpLicense* license, wStream* s);

static BOOL license_answer_license_request(rdpLicense* license);

static BOOL license_write_platform_challenge_response_packet(rdpLicense* license, wStream* s,

                                                             const BYTE* mac_data);

static BOOL license_send_platform_challenge_response_packet(rdpLicense* license);

static BOOL license_send_client_info(rdpLicense* license, const LICENSE_BLOB* calBlob,

                                     BYTE* signature);

#define PLATFORMID (CLIENT_OS_ID_WINNT_POST_52 | CLIENT_IMAGE_ID_MICROSOFT)

#ifdef WITH_DEBUG_LICENSE

static const char* const LICENSE_MESSAGE_STRINGS[] = { "",

	                                                   "License Request",

	                                                   "Platform Challenge",

	                                                   "New License",

	                                                   "Upgrade License",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "License Info",

	                                                   "New License Request",

	                                                   "",

	                                                   "Platform Challenge Response",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "",

	                                                   "Error Alert" };

static const char* const error_codes[] = { "ERR_UNKNOWN",

	                                       "ERR_INVALID_SERVER_CERTIFICATE",

	                                       "ERR_NO_LICENSE",

	                                       "ERR_INVALID_MAC",

	                                       "ERR_INVALID_SCOPE",

	                                       "ERR_UNKNOWN",

	                                       "ERR_NO_LICENSE_SERVER",

	                                       "STATUS_VALID_CLIENT",

	                                       "ERR_INVALID_CLIENT",

	                                       "ERR_UNKNOWN",

	                                       "ERR_UNKNOWN",

	                                       "ERR_INVALID_PRODUCT_ID",

	                                       "ERR_INVALID_MESSAGE_LENGTH" };

static const char* const state_transitions[] = { "ST_UNKNOWN", "ST_TOTAL_ABORT", "ST_NO_TRANSITION",

	                                             "ST_RESET_PHASE_TO_START",

	                                             "ST_RESEND_LAST_MESSAGE" };

static void license_print_product_info(const LICENSE_PRODUCT_INFO* productInfo)

{

	char* CompanyName = NULL;

	char* ProductId = NULL;

	ConvertFromUnicode(CP_UTF8, 0, (WCHAR*)productInfo->pbCompanyName,

	                   productInfo->cbCompanyName / 2, &CompanyName, 0, NULL, NULL);

	ConvertFromUnicode(CP_UTF8, 0, (WCHAR*)productInfo->pbProductId, productInfo->cbProductId / 2,

	                   &ProductId, 0, NULL, NULL);

	WLog_INFO(TAG, "ProductInfo:");

	WLog_INFO(TAG, "\tdwVersion: 0x%08" PRIX32 "", productInfo->dwVersion);

	WLog_INFO(TAG, "\tCompanyName: %s", CompanyName);

	WLog_INFO(TAG, "\tProductId: %s", ProductId);

	free(CompanyName);

	free(ProductId);

}

static void license_print_scope_list(const SCOPE_LIST* scopeList)

{

	UINT32 index;

	const LICENSE_BLOB* scope;

	WLog_INFO(TAG, "ScopeList (%" PRIu32 "):", scopeList->count);

	for (index = 0; index < scopeList->count; index++)

	{

		scope = &scopeList->array[index];

		WLog_INFO(TAG, "\t%s", (const char*)scope->data);

	}

}

#endif

static const char licenseStore[] = "licenses";

static BOOL computeCalHash(const char* hostname, char* hashStr)

{

	WINPR_DIGEST_CTX* sha1 = NULL;

	BOOL ret = FALSE;

	BYTE hash[20];

	size_t i;

	if (!(sha1 = winpr_Digest_New()))

		goto out;

	if (!winpr_Digest_Init(sha1, WINPR_MD_SHA1))

		goto out;

	if (!winpr_Digest_Update(sha1, (const BYTE*)hostname, strlen(hostname)))

		goto out;

	if (!winpr_Digest_Final(sha1, hash, sizeof(hash)))

		goto out;

	for (i = 0; i < sizeof(hash); i++, hashStr += 2)

		sprintf_s(hashStr, 3, "%.2x", hash[i]);

	ret = TRUE;

out:

	winpr_Digest_Free(sha1);

	return ret;

}

static BOOL saveCal(rdpSettings* settings, const BYTE* data, int length, char* hostname)

{

	char hash[41];

	FILE* fp;

	char* licenseStorePath = NULL;

	char filename[MAX_PATH], filenameNew[MAX_PATH];

	char *filepath = NULL, *filepathNew = NULL;

	size_t written;

	BOOL ret = FALSE;

	if (!PathFileExistsA(settings->ConfigPath))

	{

		if (!PathMakePathA(settings->ConfigPath, 0))

		{

			WLog_ERR(TAG, "error creating directory '%s'", settings->ConfigPath);

			goto out;

		}

		WLog_INFO(TAG, "creating directory %s", settings->ConfigPath);

	}

	if (!(licenseStorePath = GetCombinedPath(settings->ConfigPath, licenseStore)))

		goto out;

	if (!PathFileExistsA(licenseStorePath))

	{

		if (!PathMakePathA(licenseStorePath, 0))

		{

			WLog_ERR(TAG, "error creating directory '%s'", licenseStorePath);

			goto out;

		}

		WLog_INFO(TAG, "creating directory %s", licenseStorePath);

	}

	if (!computeCalHash(hostname, hash))

		goto out;

	sprintf_s(filename, sizeof(filename) - 1, "%s.cal", hash);

	sprintf_s(filenameNew, sizeof(filenameNew) - 1, "%s.cal.new", hash);

	if (!(filepath = GetCombinedPath(licenseStorePath, filename)))

		goto out;

	if (!(filepathNew = GetCombinedPath(licenseStorePath, filenameNew)))

		goto out;

	fp = fopen(filepathNew, "wb");

	if (!fp)

		goto out;

	written = fwrite(data, length, 1, fp);

	fclose(fp);

	if (written != 1)

	{

		DeleteFile(filepathNew);

		goto out;

	}

	ret = MoveFileEx(filepathNew, filepath, MOVEFILE_REPLACE_EXISTING);

out:

	free(filepathNew);

	free(filepath);

	free(licenseStorePath);

	return ret;

}

static BYTE* loadCalFile(rdpSettings* settings, const char* hostname, int* dataLen)

{

	char *licenseStorePath = NULL, *calPath = NULL;

	char calFilename[MAX_PATH];

	char hash[41];

	int length, status;

	FILE* fp;

	BYTE* ret = NULL;

	if (!computeCalHash(hostname, hash))

	{

		WLog_ERR(TAG, "loadCalFile: unable to compute hostname hash");

		return NULL;

	}

	sprintf_s(calFilename, sizeof(calFilename) - 1, "%s.cal", hash);

	if (!(licenseStorePath = GetCombinedPath(settings->ConfigPath, licenseStore)))

		return NULL;

	if (!(calPath = GetCombinedPath(licenseStorePath, calFilename)))

		goto error_path;

	fp = fopen(calPath, "rb");

	if (!fp)

		goto error_open;

	_fseeki64(fp, 0, SEEK_END);

	length = _ftelli64(fp);

	_fseeki64(fp, 0, SEEK_SET);

	ret = (BYTE*)malloc(length);

	if (!ret)

		goto error_malloc;

	status = fread(ret, length, 1, fp);

	if (status <= 0)

		goto error_read;

	*dataLen = length;

	fclose(fp);

	free(calPath);

	free(licenseStorePath);

	return ret;

error_read:

	free(ret);

error_malloc:

	fclose(fp);

error_open:

	free(calPath);

error_path:

	free(licenseStorePath);

	return NULL;

}

/**

 * Read a licensing preamble.\n

 * @msdn{cc240480}

 * @param s stream

 * @param bMsgType license message type

 * @param flags message flags

 * @param wMsgSize message size

 * @return if the operation completed successfully

 */

static BOOL license_read_preamble(wStream* s, BYTE* bMsgType, BYTE* flags, UINT16* wMsgSize)

{

	/* preamble (4 bytes) */

	if (Stream_GetRemainingLength(s) < 4)

		return FALSE;

	Stream_Read_UINT8(s, *bMsgType);  /* bMsgType (1 byte) */

	Stream_Read_UINT8(s, *flags);     /* flags (1 byte) */

	Stream_Read_UINT16(s, *wMsgSize); /* wMsgSize (2 bytes) */

	return TRUE;

}

/**

 * Write a licensing preamble.\n

 * @msdn{cc240480}

 * @param s stream

 * @param bMsgType license message type

 * @param flags message flags

 * @param wMsgSize message size

 */

static BOOL license_write_preamble(wStream* s, BYTE bMsgType, BYTE flags, UINT16 wMsgSize)

{

	if (!Stream_EnsureRemainingCapacity(s, 4))

		return FALSE;

	/* preamble (4 bytes) */

	Stream_Write_UINT8(s, bMsgType);  /* bMsgType (1 byte) */

	Stream_Write_UINT8(s, flags);     /* flags (1 byte) */

	Stream_Write_UINT16(s, wMsgSize); /* wMsgSize (2 bytes) */

	return TRUE;

}

/**

 * Initialize a license packet stream.\n

 * @param license license module

 * @return stream

 */

wStream* license_send_stream_init(rdpLicense* license)

{

	wStream* s;

	BOOL do_crypt = license->rdp->do_crypt;

	license->rdp->sec_flags = SEC_LICENSE_PKT;

	/**

	 * Encryption of licensing packets is optional even if the rdp security

	 * layer is used. If the peer has not indicated that it is capable of

	 * processing encrypted licensing packets (rdp->do_crypt_license) we turn

	 * off encryption (via rdp->do_crypt) before initializing the rdp stream

	 * and reenable it afterwards.

	 */

	if (do_crypt)

	{

		license->rdp->sec_flags |= SEC_LICENSE_ENCRYPT_CS;

		license->rdp->do_crypt = license->rdp->do_crypt_license;

	}

	s = rdp_send_stream_init(license->rdp);

	if (!s)

		return NULL;

	license->rdp->do_crypt = do_crypt;

	license->PacketHeaderLength = Stream_GetPosition(s);

	if (!Stream_SafeSeek(s, LICENSE_PREAMBLE_LENGTH))

		goto fail;

	return s;

fail:

	Stream_Release(s);

	return NULL;

}

/**

 * Send an RDP licensing packet.\n

 * @msdn{cc240479}

 * @param license license module

 * @param s stream

 */

static BOOL license_send(rdpLicense* license, wStream* s, BYTE type)

{

	size_t length;

	BYTE flags;

	UINT16 wMsgSize;

	rdpRdp* rdp = license->rdp;

	BOOL ret;

	DEBUG_LICENSE("Sending %s Packet", LICENSE_MESSAGE_STRINGS[type & 0x1F]);

	length = Stream_GetPosition(s);

	wMsgSize = length - license->PacketHeaderLength;

	Stream_SetPosition(s, license->PacketHeaderLength);

	flags = PREAMBLE_VERSION_3_0;

	/**

	 * Using EXTENDED_ERROR_MSG_SUPPORTED here would cause mstsc to crash when

	 * running in server mode! This flag seems to be incorrectly documented.

	 */

	if (!rdp->settings->ServerMode)

		flags |= EXTENDED_ERROR_MSG_SUPPORTED;

	if (!license_write_preamble(s, type, flags, wMsgSize))

		return FALSE;

#ifdef WITH_DEBUG_LICENSE

	WLog_DBG(TAG, "Sending %s Packet, length %" PRIu16 "", LICENSE_MESSAGE_STRINGS[type & 0x1F],

	         wMsgSize);

	winpr_HexDump(TAG, WLOG_DEBUG, Stream_Pointer(s) - LICENSE_PREAMBLE_LENGTH, wMsgSize);

#endif

	Stream_SetPosition(s, length);

	ret = rdp_send(rdp, s, MCS_GLOBAL_CHANNEL_ID);

	rdp->sec_flags = 0;

	return ret;

}

/**

 * Receive an RDP licensing packet.\n

 * @msdn{cc240479}

 * @param license license module

 * @param s stream

 * @return if the operation completed successfully

 */

int license_recv(rdpLicense* license, wStream* s)

{

	BYTE flags;

	BYTE bMsgType;

	UINT16 wMsgSize;

	UINT16 length;

	UINT16 channelId;

	UINT16 securityFlags = 0;

	if (!rdp_read_header(license->rdp, s, &length, &channelId))

	{

		WLog_ERR(TAG, "Incorrect RDP header.");

		return -1;

	}

	if (!rdp_read_security_header(s, &securityFlags, &length))

		return -1;

	if (securityFlags & SEC_ENCRYPT)

	{

		if (!rdp_decrypt(license->rdp, s, &length, securityFlags))

		{

			WLog_ERR(TAG, "rdp_decrypt failed");

			return -1;

		}

	}

	if (!(securityFlags & SEC_LICENSE_PKT))

	{

		int status;

		if (!(securityFlags & SEC_ENCRYPT))

			Stream_Rewind(s, RDP_SECURITY_HEADER_LENGTH);

		status = rdp_recv_out_of_sequence_pdu(license->rdp, s);

		if (status < 0)

		{

			WLog_ERR(TAG, "unexpected license packet.");

			return status;

		}

		return 0;

	}

	if (!license_read_preamble(s, &bMsgType, &flags, &wMsgSize)) /* preamble (4 bytes) */

		return -1;

	DEBUG_LICENSE("Receiving %s Packet", LICENSE_MESSAGE_STRINGS[bMsgType & 0x1F]);

	switch (bMsgType)

	{

		case LICENSE_REQUEST:

			if (!license_read_license_request_packet(license, s))

				return -1;

			if (!license_answer_license_request(license))

				return -1;

			break;

		case PLATFORM_CHALLENGE:

			if (!license_read_platform_challenge_packet(license, s))

				return -1;

			if (!license_send_platform_challenge_response_packet(license))

				return -1;

			break;

		case NEW_LICENSE:

		case UPGRADE_LICENSE:

			if (!license_read_new_or_upgrade_license_packet(license, s))

				return -1;

			break;

		case ERROR_ALERT:

			if (!license_read_error_alert_packet(license, s))

				return -1;

			break;

		default:

			WLog_ERR(TAG, "invalid bMsgType:%" PRIu8 "", bMsgType);

			return -1;

	}

	if (!tpkt_ensure_stream_consumed(s, length))

		return -1;

	return 0;

}

void license_generate_randoms(rdpLicense* license)

{

#ifdef LICENSE_NULL_CLIENT_RANDOM

	ZeroMemory(license->ClientRandom, CLIENT_RANDOM_LENGTH); /* ClientRandom */

#else

	winpr_RAND(license->ClientRandom, CLIENT_RANDOM_LENGTH);       /* ClientRandom */

#endif

#ifdef LICENSE_NULL_PREMASTER_SECRET

	ZeroMemory(license->PremasterSecret, PREMASTER_SECRET_LENGTH); /* PremasterSecret */

#else

	winpr_RAND(license->PremasterSecret, PREMASTER_SECRET_LENGTH); /* PremasterSecret */

#endif

}

/**

 * Generate License Cryptographic Keys.

 * @param license license module

 */

static BOOL license_generate_keys(rdpLicense* license)

{

	BOOL ret;

	if (

	    /* MasterSecret */

	    !security_master_secret(license->PremasterSecret, license->ClientRandom,

	                            license->ServerRandom, license->MasterSecret) ||

	    /* SessionKeyBlob */

	    !security_session_key_blob(license->MasterSecret, license->ClientRandom,

	                               license->ServerRandom, license->SessionKeyBlob))

	{

		return FALSE;

	}

	security_mac_salt_key(license->SessionKeyBlob, license->ClientRandom, license->ServerRandom,

	                      license->MacSaltKey); /* MacSaltKey */

	ret = security_licensing_encryption_key(

	    license->SessionKeyBlob, license->ClientRandom, license->ServerRandom,

	    license->LicensingEncryptionKey); /* LicensingEncryptionKey */

#ifdef WITH_DEBUG_LICENSE

	WLog_DBG(TAG, "ClientRandom:");

	winpr_HexDump(TAG, WLOG_DEBUG, license->ClientRandom, CLIENT_RANDOM_LENGTH);

	WLog_DBG(TAG, "ServerRandom:");

	winpr_HexDump(TAG, WLOG_DEBUG, license->ServerRandom, SERVER_RANDOM_LENGTH);

	WLog_DBG(TAG, "PremasterSecret:");

	winpr_HexDump(TAG, WLOG_DEBUG, license->PremasterSecret, PREMASTER_SECRET_LENGTH);

	WLog_DBG(TAG, "MasterSecret:");

	winpr_HexDump(TAG, WLOG_DEBUG, license->MasterSecret, MASTER_SECRET_LENGTH);

	WLog_DBG(TAG, "SessionKeyBlob:");

	winpr_HexDump(TAG, WLOG_DEBUG, license->SessionKeyBlob, SESSION_KEY_BLOB_LENGTH);

	WLog_DBG(TAG, "MacSaltKey:");

	winpr_HexDump(TAG, WLOG_DEBUG, license->MacSaltKey, MAC_SALT_KEY_LENGTH);

	WLog_DBG(TAG, "LicensingEncryptionKey:");

	winpr_HexDump(TAG, WLOG_DEBUG, license->LicensingEncryptionKey,

	              LICENSING_ENCRYPTION_KEY_LENGTH);

#endif

	return ret;

}

/**

 * Generate Unique Hardware Identifier (CLIENT_HARDWARE_ID).\n

 * @param license license module

 */

BOOL license_generate_hwid(rdpLicense* license)

{

	const BYTE* hashTarget;

	size_t targetLen;

	BYTE macAddress[6];

	ZeroMemory(license->HardwareId, HWID_LENGTH);

	if (license->rdp->settings->OldLicenseBehaviour)

	{

		ZeroMemory(macAddress, sizeof(macAddress));

		hashTarget = macAddress;

		targetLen = sizeof(macAddress);

	}

	else

	{

		wStream s;

		const char* hostname = license->rdp->settings->ClientHostname;

		Stream_StaticInit(&s, license->HardwareId, 4);

		Stream_Write_UINT32(&s, PLATFORMID);

		Stream_Free(&s, TRUE);

		hashTarget = (const BYTE*)hostname;

		targetLen = strlen(hostname);

	}

	/* Allow FIPS override for use of MD5 here, really this does not have to be MD5 as we are just

	 * taking a MD5 hash of the 6 bytes of 0's(macAddress) */

	/* and filling in the Data1-Data4 fields of the CLIENT_HARDWARE_ID structure(from MS-RDPELE

	 * section 2.2.2.3.1). This is for RDP licensing packets */

	/* which will already be encrypted under FIPS, so the use of MD5 here is not for sensitive data

	 * protection. */

	return winpr_Digest_Allow_FIPS(WINPR_MD_MD5, hashTarget, targetLen,

	                               &license->HardwareId[HWID_PLATFORM_ID_LENGTH],

	                               WINPR_MD5_DIGEST_LENGTH);

}

static BOOL license_get_server_rsa_public_key(rdpLicense* license)

{

	BYTE* Exponent;

	BYTE* Modulus;

	int ModulusLength;

	rdpSettings* settings = license->rdp->settings;

	if (license->ServerCertificate->length < 1)

	{

		if (!certificate_read_server_certificate(license->certificate, settings->ServerCertificate,

		                                         settings->ServerCertificateLength))

			return FALSE;

	}

	Exponent = license->certificate->cert_info.exponent;

	Modulus = license->certificate->cert_info.Modulus;

	ModulusLength = license->certificate->cert_info.ModulusLength;

	CopyMemory(license->Exponent, Exponent, 4);

	license->ModulusLength = ModulusLength;

	license->Modulus = (BYTE*)malloc(ModulusLength);

	if (!license->Modulus)

		return FALSE;

	CopyMemory(license->Modulus, Modulus, ModulusLength);

	return TRUE;

}

BOOL license_encrypt_premaster_secret(rdpLicense* license)

{

	BYTE* EncryptedPremasterSecret;

	if (!license_get_server_rsa_public_key(license))

		return FALSE;

#ifdef WITH_DEBUG_LICENSE

	WLog_DBG(TAG, "Modulus (%" PRIu32 " bits):", license->ModulusLength * 8);

	winpr_HexDump(TAG, WLOG_DEBUG, license->Modulus, license->ModulusLength);

	WLog_DBG(TAG, "Exponent:");

	winpr_HexDump(TAG, WLOG_DEBUG, license->Exponent, 4);

#endif

	EncryptedPremasterSecret = (BYTE*)calloc(1, license->ModulusLength);

	if (!EncryptedPremasterSecret)

		return FALSE;

	license->EncryptedPremasterSecret->type = BB_RANDOM_BLOB;

	license->EncryptedPremasterSecret->length = PREMASTER_SECRET_LENGTH;

#ifndef LICENSE_NULL_PREMASTER_SECRET

	license->EncryptedPremasterSecret->length = crypto_rsa_public_encrypt(

	    license->PremasterSecret, PREMASTER_SECRET_LENGTH, license->ModulusLength, license->Modulus,

	    license->Exponent, EncryptedPremasterSecret);

#endif

	license->EncryptedPremasterSecret->data = EncryptedPremasterSecret;

	return TRUE;

}

static BOOL license_rc4_with_licenseKey(const rdpLicense* license, const BYTE* input, size_t len,

                                        LICENSE_BLOB* target)

{

	WINPR_RC4_CTX* rc4;

	BYTE* buffer = NULL;

	rc4 =

	    winpr_RC4_New_Allow_FIPS(license->LicensingEncryptionKey, LICENSING_ENCRYPTION_KEY_LENGTH);

	if (!rc4)

		return FALSE;

	buffer = (BYTE*)realloc(target->data, len);

	if (!buffer)

		goto error_buffer;

	target->data = buffer;

	target->length = len;

	if (!winpr_RC4_Update(rc4, len, input, buffer))

		goto error_buffer;

	winpr_RC4_Free(rc4);

	return TRUE;

error_buffer:

	winpr_RC4_Free(rc4);

	return FALSE;

}

/**

 * Encrypt the input using the license key and MAC the input for a signature

 *

 * @param license rdpLicense to get keys and salt from

 * @param input the input data to encrypt and MAC

 * @param len size of input

 * @param target a target LICENSE_BLOB where the encrypted input will be stored

 * @param mac the signature buffer (16 bytes)

 * @return if the operation completed successfully

 */

static BOOL license_encrypt_and_MAC(rdpLicense* license, const BYTE* input, size_t len,

                                    LICENSE_BLOB* target, BYTE* mac)

{

	return license_rc4_with_licenseKey(license, input, len, target) &&

	       security_mac_data(license->MacSaltKey, input, len, mac);

}

/**

 * Decrypt the input using the license key and check the MAC

 *

 * @param license rdpLicense to get keys and salt from

 * @param input the input data to decrypt and MAC

 * @param len size of input

 * @param target a target LICENSE_BLOB where the decrypted input will be stored

 * @param mac the signature buffer (16 bytes)

 * @return if the operation completed successfully

 */

static BOOL license_decrypt_and_check_MAC(rdpLicense* license, const BYTE* input, size_t len,

                                          LICENSE_BLOB* target, const BYTE* packetMac)

{

	BYTE macData[16];

	return license_rc4_with_licenseKey(license, input, len, target) &&

	       security_mac_data(license->MacSaltKey, target->data, len, macData) &&

	       (memcmp(packetMac, macData, sizeof(macData)) == 0);

}

/**

 * Read Product Information (PRODUCT_INFO).\n

 * @msdn{cc241915}

 * @param s stream

 * @param productInfo product information

 */

BOOL license_read_product_info(wStream* s, LICENSE_PRODUCT_INFO* productInfo)

{

	if (Stream_GetRemainingLength(s) < 8)

		return FALSE;

	Stream_Read_UINT32(s, productInfo->dwVersion);     /* dwVersion (4 bytes) */

	Stream_Read_UINT32(s, productInfo->cbCompanyName); /* cbCompanyName (4 bytes) */

	/* Name must be >0, but there is no upper limit defined, use UINT32_MAX */

	if ((productInfo->cbCompanyName < 2) || (productInfo->cbCompanyName % 2 != 0))

		return FALSE;

	if (Stream_GetRemainingLength(s) < productInfo->cbCompanyName)

		return FALSE;

	productInfo->pbProductId = NULL;

	productInfo->pbCompanyName = (BYTE*)malloc(productInfo->cbCompanyName);

	if (!productInfo->pbCompanyName)

		return FALSE;

	Stream_Read(s, productInfo->pbCompanyName, productInfo->cbCompanyName);

	if (Stream_GetRemainingLength(s) < 4)

		goto out_fail;

	Stream_Read_UINT32(s, productInfo->cbProductId); /* cbProductId (4 bytes) */

	if ((productInfo->cbProductId < 2) || (productInfo->cbProductId % 2 != 0))

		goto out_fail;

	if (Stream_GetRemainingLength(s) < productInfo->cbProductId)

		goto out_fail;

	productInfo->pbProductId = (BYTE*)malloc(productInfo->cbProductId);

	if (!productInfo->pbProductId)

		goto out_fail;

	Stream_Read(s, productInfo->pbProductId, productInfo->cbProductId);

	return TRUE;

out_fail:

	free(productInfo->pbCompanyName);

	free(productInfo->pbProductId);

	productInfo->pbCompanyName = NULL;

	productInfo->pbProductId = NULL;

	return FALSE;

}

/**

 * Allocate New Product Information (LICENSE_PRODUCT_INFO).\n

 * @msdn{cc241915}

 * @return new product information

 */

LICENSE_PRODUCT_INFO* license_new_product_info()

{

	LICENSE_PRODUCT_INFO* productInfo;

	productInfo = (LICENSE_PRODUCT_INFO*)malloc(sizeof(LICENSE_PRODUCT_INFO));

	if (!productInfo)

		return NULL;

	productInfo->dwVersion = 0;

	productInfo->cbCompanyName = 0;

	productInfo->pbCompanyName = NULL;

	productInfo->cbProductId = 0;

	productInfo->pbProductId = NULL;

	return productInfo;

}

/**

 * Free Product Information (LICENSE_PRODUCT_INFO).\n

 * @msdn{cc241915}

 * @param productInfo product information

 */

void license_free_product_info(LICENSE_PRODUCT_INFO* productInfo)

{

	if (productInfo)

	{

		free(productInfo->pbCompanyName);

		free(productInfo->pbProductId);

		free(productInfo);

	}

}

/**

 * Read License Binary Blob (LICENSE_BINARY_BLOB).\n

 * @msdn{cc240481}

 * @param s stream

 * @param blob license binary blob

 */

BOOL license_read_binary_blob(wStream* s, LICENSE_BLOB* blob)

{

	UINT16 wBlobType;

	if (Stream_GetRemainingLength(s) < 4)

		return FALSE;

	Stream_Read_UINT16(s, wBlobType);    /* wBlobType (2 bytes) */

	Stream_Read_UINT16(s, blob->length); /* wBlobLen (2 bytes) */

	if (Stream_GetRemainingLength(s) < blob->length)

		return FALSE;

	/*

	 * Server can choose to not send data by setting length to 0.

	 * If so, it may not bother to set the type, so shortcut the warning

	 */

	if ((blob->type != BB_ANY_BLOB) && (blob->length == 0))

		return TRUE;

	if ((blob->type != wBlobType) && (blob->type != BB_ANY_BLOB))

	{

		WLog_ERR(TAG,

		         "license binary blob type (0x%" PRIx16 ") does not match expected type (0x%" PRIx16

		         ").",