module-emulator-viaccess.c

#define MODULE_LOG_PREFIX "emu"

#include "globals.h"

#ifdef WITH_EMU

#include "cscrypt/des.h"
#include "module-emulator-osemu.h"
#include "module-newcamd-des.h"
#include "oscam-aes.h"
#include "oscam-string.h"

// from reader-viaccess.c:
void hdSurEncPhase1_D2_0F_11(uint8_t *CWs);
void hdSurEncPhase2_D2_0F_11(uint8_t *CWs);
void hdSurEncPhase1_D2_13_15(uint8_t *cws);
void hdSurEncPhase2_D2_13_15(uint8_t *cws);

// Viaccess EMU

static int8_t get_key(uint8_t *buf, uint32_t ident, char keyName, uint32_t keyIndex,
						uint32_t keyLength, uint8_t isCriticalKey)
{
	char keyStr[EMU_MAX_CHAR_KEYNAME];
	snprintf(keyStr, EMU_MAX_CHAR_KEYNAME, "%c%X", keyName, keyIndex);

	if (emu_find_key('V', ident, 0, keyStr, buf, keyLength, isCriticalKey, 0, 0, NULL))
	{
		return 1;
	}

	if (ident == 0xD00040 && emu_find_key('V', 0x030B00, 0, keyStr, buf, keyLength, isCriticalKey, 0, 0, NULL))
	{
		return 1;
	}

	return 0;
}

static void via1_mod(const uint8_t *key2, uint8_t *data)
{
	int32_t kb, db;

	for (db = 7; db >= 0; db--)
	{
		for (kb = 7; kb > 3; kb--)
		{
			int32_t a0 = kb ^ db;
			int32_t pos = 7;

			if (a0 & 4)
			{
				a0 ^= 7;
				pos ^= 7;
			}

			a0 = (a0 ^ (kb & 3)) + (kb & 3);

			if (!(a0 & 4))
			{
				data[db] ^= (key2[kb] ^ ((data[kb ^ pos] * key2[kb ^ 4]) & 0xFF));
			}
		}
	}

	for (db = 0; db < 8; db++)
	{
		for (kb = 0; kb < 4; kb++)
		{
			int32_t a0 = kb ^ db;
			int32_t pos = 7;

			if (a0 & 4)
			{
				a0 ^= 7;
				pos ^= 7;
			}

			a0 = (a0 ^ (kb & 3)) + (kb & 3);

			if (!(a0 & 4))
			{
				data[db] ^= (key2[kb] ^ ((data[kb ^ pos] * key2[kb ^ 4]) & 0xFF));
			}
		}
	}
}

static void via1_decode(uint8_t *data, uint8_t *key)
{
	via1_mod(key + 8, data);
	nc_des(key, DES_ECM_CRYPT, data);
	via1_mod(key + 8, data);
}

static void via1_hash(uint8_t *data, uint8_t *key)
{
	via1_mod(key + 8, data);
	nc_des(key, DES_ECM_HASH, data);
	via1_mod(key + 8, data);
}

static inline void via1_do_hash(uint8_t *hashbuffer, uint8_t *pH, uint8_t data, uint8_t *hashkey)
{
	hashbuffer[*pH] ^= data;
	(*pH)++;

	if (*pH == 8)
	{
		via1_hash(hashbuffer, hashkey);
		*pH = 0;
	}
}

static int8_t via1_decrypt(uint8_t *ecm, uint8_t *dw, uint32_t ident, uint8_t desKeyIndex)
{
	int32_t msg_pos, encStart = 0, hash_start, i;

	uint8_t tmp, k, pH, foundData = 0;
	uint8_t work_key[16], signature[8], hashbuffer[8], prepared_key[16], hashkey[16];
	uint8_t *data, *des_data1, *des_data2;

	uint16_t ecmLen = SCT_LEN(ecm);

	if (ident == 0)
	{
		return EMU_CORRUPT_DATA;
	}

	memset(work_key, 0, 16);

	if (!get_key(work_key, ident, '0', desKeyIndex, 8, 1))
	{
		return EMU_KEY_NOT_FOUND;
	}

	if (ecmLen < 11)
	{
		return EMU_NOT_SUPPORTED;
	}

	data = ecm + 9;
	des_data1 = dw;
	des_data2 = dw + 8;

	msg_pos = 0;
	pH = 0;
	memset(hashbuffer, 0, sizeof(hashbuffer));
	memcpy(hashkey, work_key, sizeof(hashkey));
	memset(signature, 0, 8);

	while (9 + msg_pos + 2 < ecmLen)
	{
		switch (data[msg_pos])
		{
			case 0xEA:
				if (9 + msg_pos + 2 + 15 < ecmLen)
				{
					encStart = msg_pos + 2;
					memcpy(des_data1, &data[msg_pos + 2], 8);
					memcpy(des_data2, &data[msg_pos + 2 + 8], 8);
					foundData |= 1;
				}
				break;

			case 0xF0:
				if (9 + msg_pos + 2 + 7 < ecmLen)
				{
					memcpy(signature, &data[msg_pos + 2], 8);
					foundData |= 2;
				}
				break;
		}
		msg_pos += data[msg_pos + 1] + 2;
	}

	if (foundData != 3)
	{
		return EMU_NOT_SUPPORTED;
	}

	pH = i = 0;

	if (data[0] == 0x9F && 10 + data[1] <= ecmLen)
	{
		via1_do_hash(hashbuffer, &pH, data[i++], hashkey);
		via1_do_hash(hashbuffer, &pH, data[i++], hashkey);

		for (hash_start = 0; hash_start < data[1]; hash_start++)
		{
			via1_do_hash(hashbuffer, &pH, data[i++], hashkey);
		}

		while (pH != 0)
		{
			via1_do_hash(hashbuffer, &pH, 0, hashkey);
		}
	}

	if (work_key[7] == 0)
	{
		for (; i < encStart + 16; i++)
		{
			via1_do_hash(hashbuffer, &pH, data[i], hashkey);
		}
		memcpy(prepared_key, work_key, 8);
	}
	else
	{
		prepared_key[0] = work_key[2];
		prepared_key[1] = work_key[3];
		prepared_key[2] = work_key[4];
		prepared_key[3] = work_key[5];
		prepared_key[4] = work_key[6];
		prepared_key[5] = work_key[0];
		prepared_key[6] = work_key[1];
		prepared_key[7] = work_key[7];

		memcpy(prepared_key + 8, work_key + 8, 8);

		if (work_key[7] & 1)
		{
			for (; i < encStart; i++)
			{
				via1_do_hash(hashbuffer, &pH, data[i], hashkey);
			}

			k = ((work_key[7] & 0xF0) == 0) ? 0x5A : 0xA5;

			for (i = 0; i < 8; i++)
			{
				tmp = des_data1[i];
				des_data1[i] = (k & hashbuffer[pH] ) ^ tmp;
				via1_do_hash(hashbuffer, &pH, tmp, hashkey);
			}

			for (i = 0; i < 8; i++)
			{
				tmp = des_data2[i];
				des_data2[i] = (k & hashbuffer[pH] ) ^ tmp;
				via1_do_hash(hashbuffer, &pH, tmp, hashkey);
			}
		}
		else
		{
			for ( ; i < encStart + 16; i++)
			{
				via1_do_hash(hashbuffer, &pH, data[i], hashkey);
			}
		}
	}

	via1_decode(des_data1, prepared_key);
	via1_decode(des_data2, prepared_key);
	via1_hash(hashbuffer, hashkey);

	if (memcmp(signature, hashbuffer, 8))
	{
		return EMU_CHECKSUM_ERROR;
	}

	return EMU_OK;
}

static int8_t via26_process_dw(uint8_t *indata, uint32_t ident, uint8_t desKeyIndex)
{
	uint8_t pv1,pv2, i;
	uint8_t Tmp[8], T1Key[300], P1Key[8], KeyDes1[16], KeyDes2[16], XorKey[8];
	uint32_t ks1[32], ks2[32];

	if (!get_key(T1Key, ident, 'T', 1, 300, 1))
	{
		return 2;
	}

	if (!get_key(P1Key, ident, 'P', 1, 8, 1))
	{
		return 2;
	}

	if (!get_key(KeyDes1, ident, 'D', 1, 16, 1))
	{
		return 2;
	}

	if (!get_key(KeyDes2, ident, '0', desKeyIndex, 16, 1))
	{
		return 2;
	}

	if (!get_key(XorKey, ident, 'X', 1, 8, 1))
	{
		return 2;
	}

	for (i = 0; i < 8; i++)
	{
		pv1 = indata[i];
		Tmp[i] = T1Key[pv1];
	}

	for (i = 0; i < 8; i++)
	{
		pv1 = P1Key[i];
		pv2 = Tmp[pv1];
		indata[i] = pv2;
	}

	des_set_key(KeyDes1, ks1);
	des(indata, ks1, 1);

	for (i = 0; i < 8; i++)
	{
		indata[i] ^= XorKey[i];
	}

	des_set_key(KeyDes2, ks1);
	des_set_key(KeyDes2 + 8, ks2);
	des(indata, ks1, 0);
	des(indata, ks2, 1);
	des(indata, ks1, 0);

	for (i = 0; i < 8; i++)
	{
		indata[i] ^= XorKey[i];
	}

	des_set_key(KeyDes1, ks1);
	des(indata, ks1, 0);

	for (i = 0; i < 8; i++)
	{
		pv1 = indata[i];
		pv2 = P1Key[i];
		Tmp[pv2] = pv1;
	}

	for (i = 0; i < 8; i++)
	{
		pv1 = Tmp[i];
		pv2 = T1Key[pv1];
		indata[i] = pv2;
	}

	return 0;
}

static int8_t via26_decrypt(uint8_t *source, uint8_t *dw, uint32_t ident, uint8_t desKeyIndex)
{
	uint8_t tmpData[8], C1[8];
	uint8_t *pXorVector;
	int32_t i, j;

	if (ident == 0)
	{
		return EMU_CORRUPT_DATA;
	}

	if (!get_key(C1, ident, 'C', 1, 8, 1))
	{
		return EMU_KEY_NOT_FOUND;
	}

	for (i = 0; i < 2; i++)
	{
		memcpy(tmpData, source + i * 8, 8);
		via26_process_dw(tmpData, ident, desKeyIndex);

		if (i != 0)
		{
			pXorVector = source;
		}
		else
		{
			pXorVector = &C1[0];
		}

		for (j = 0; j < 8; j++)
		{
			dw[i * 8 + j] = tmpData[j] ^ pXorVector[j];
		}

		// Fix CW checksum bytes
		for (j = 3; j < 8; j += 4)
		{
			dw[i * 8 + j] = (dw[i * 8 + j - 3] + dw[i * 8 + j - 2] + dw[i * 8 + j - 1]) & 0xFF;
		}
	}

	return EMU_OK;
}

static void via3_core(uint8_t *data, uint8_t Off, uint32_t ident, uint8_t *XorKey, uint8_t *T1Key)
{
	uint8_t i;
	uint32_t lR2, lR3, lR4, lR6, lR7;

	switch (ident)
	{
		case 0x032820:
		{
			for (i = 0; i < 4; i++)
			{
				data[i] ^= XorKey[(Off + i) & 0x07];
			}

			lR2 = (data[0] ^ 0xBD) + data[0];
			lR3 = (data[3] ^ 0xEB) + data[3];
			lR2 = (lR2 - lR3) ^ data[2];
			lR3 = ((0x39 * data[1]) << 2);
			data[4] = (lR2 | lR3) + data[2];

			lR3 = ((((data[0] + 6) ^ data[0]) | (data[2] << 1)) ^ 0x65) + data[0];
			lR2 = (data[1] ^ 0xED) + data[1];
			lR7 = ((data[3] + 0x29) ^ data[3]) * lR2;
			data[5] = lR7 + lR3;

			lR2 = ((data[2] ^ 0x33) + data[2]) & 0x0A;
			lR3 = (data[0] + 0xAD) ^ data[0];
			lR3 = lR3 + lR2;
			lR2 = data[3] * data[3];
			lR7 = (lR2 | 1) + data[1];
			data[6] = (lR3 | lR7) + data[1];

			lR3 = data[1] & 0x07;
			lR2 = (lR3 - data[2]) & (data[0] | lR2 | 0x01);
			data[7] = lR2 + data[3];

			for (i = 0; i < 4; i++)
			{
				data[i + 4] = T1Key[data[i + 4]];
			}
		}
		break;

		case 0x030B00:
		{
			for (i = 0; i < 4; i++)
			{
				data[i] ^= XorKey[(Off + i) & 0x07];
			}

			lR6 = (data[3] + 0x6E) ^ data[3];
			lR6 = (lR6 * (data[2] << 1)) + 0x17;
			lR3 = (data[1] + 0x77) ^ data[1];
			lR4 = (data[0] + 0xD7) ^ data[0];
			data[4] = ((lR4 & lR3) | lR6) + data[0];

			lR4 = ((data[3] + 0x71) ^ data[3]) ^ 0x90;
			lR6 = (data[1] + 0x1B) ^ data[1];
			lR4 = (lR4 * lR6) ^ data[0];
			data[5] = (lR4 ^ (data[2] << 1)) + data[1];

			lR3 = (data[3] * data[3]) | 0x01;
			lR4 = (((data[2] ^ 0x35) + data[2]) | lR3) + data[2];
			lR6 = data[1] ^ (data[0] + 0x4A);
			data[6] = lR6 + lR4;

			lR3 = (data[0] * (data[2] << 1)) | data[1];
			lR4 = 0xFE - data[3];
			lR3 = lR4 ^ lR3;
			data[7] = lR3 + data[3];

			for (i = 0; i < 4; i++)
			{
				data[4 + i] = T1Key[data[4 + i]];
			}
		}
		break;

		default:
			break;
	}
}

static void via3_fct1(uint8_t *data, uint32_t ident, uint8_t *XorKey, uint8_t *T1Key)
{
	uint8_t t;

	via3_core(data, 0, ident, XorKey, T1Key);

	switch (ident)
	{
		case 0x032820:
		{
			t = data[4];
			data[4] = data[7];
			data[7] = t;
		}
		break;

		case 0x030B00:
		{
			t = data[5];
			data[5] = data[7];
			data[7] = t;
		}
		break;

		default:
			break;
	}
}

static void via3_fct2(uint8_t *data, uint32_t ident, uint8_t *XorKey, uint8_t *T1Key)
{
	uint8_t t;

	via3_core(data, 4, ident, XorKey, T1Key);

	switch (ident)
	{
		case 0x032820:
		{
			t = data[4];
			data[4] = data[7];
			data[7] = data[5];
			data[5] = data[6];
			data[6] = t;
		}
		break;

		case 0x030B00:
		{
			t = data[6];
			data[6] = data[7];
			data[7] = t;
		}
		break;

		default:
			break;
	}
}

static int8_t via3_process_dw(uint8_t *data, uint32_t ident, uint8_t desKeyIndex)
{
	uint8_t i;
	uint8_t tmp[8], T1Key[300], P1Key[8], KeyDes[16], XorKey[8];
	uint32_t ks1[32], ks2[32];

	if (!get_key(T1Key, ident, 'T', 1, 300, 1))
	{
		return 2;
	}

	if (!get_key(P1Key, ident, 'P', 1, 8, 1))
	{
		return 2;
	}

	if (!get_key(KeyDes, ident, '0', desKeyIndex, 16, 1))
	{
		return 2;
	}

	if (!get_key(XorKey, ident, 'X', 1, 8, 1))
	{
		return 2;
	}

	for (i = 0; i < 4; i++)
	{
		tmp[i] = data[i + 4];
	}

	via3_fct1(tmp, ident, XorKey, T1Key);

	for (i = 0; i < 4; i++)
	{
		tmp[i] = data[i] ^ tmp[i + 4];
	}

	via3_fct2(tmp, ident, XorKey, T1Key);

	for (i = 0; i < 4; i++)
	{
		tmp[i] ^= XorKey[i + 4];
	}

	for (i = 0; i < 4; i++)
	{
		data[i] = data[i + 4] ^ tmp[i + 4];
		data[i + 4] = tmp[i];
	}

	des_set_key(KeyDes, ks1);
	des_set_key(KeyDes + 8, ks2);

	des(data, ks1, 0);
	des(data, ks2, 1);
	des(data, ks1, 0);

	for (i = 0; i < 4; i++)
	{
		tmp[i] = data[i + 4];
	}

	via3_fct2(tmp, ident, XorKey, T1Key);

	for (i = 0; i < 4; i++)
	{
		tmp[i] = data[i] ^ tmp[i + 4];
	}

	via3_fct1(tmp, ident, XorKey, T1Key);

	for (i = 0; i < 4; i++)
	{
		tmp[i] ^= XorKey[i];
	}

	for (i = 0; i < 4; i++)
	{
		data[i] = data[i + 4] ^ tmp[i + 4];
		data[i + 4] = tmp[i];
	}

	return 0;
}

static void via3_final_mix(uint8_t *dw)
{
	uint8_t tmp[4];

	memcpy(tmp, dw, 4);
	memcpy(dw, dw + 4, 4);
	memcpy(dw + 4, tmp, 4);

	memcpy(tmp, dw + 8, 4);
	memcpy(dw + 8, dw + 12, 4);
	memcpy(dw + 12, tmp, 4);
}

static int8_t via3_decrypt(uint8_t *source, uint8_t *dw, uint32_t ident, uint8_t desKeyIndex,
							uint8_t aesKeyIndex, uint8_t aesMode, int8_t doFinalMix)
{
	int8_t aesAfterCore = 0, needsAES = (aesKeyIndex != 0xFF);
	int32_t i, j;

	uint8_t tmpData[8], C1[8];
	uint8_t *pXorVector;

	char aesKey[16];

	if (ident == 0)
	{
		return EMU_CORRUPT_DATA;
	}

	if (!get_key(C1, ident, 'C', 1, 8, 1))
	{
		return EMU_KEY_NOT_FOUND;
	}

	if (needsAES && !get_key((uint8_t *)aesKey, ident, 'E', aesKeyIndex, 16, 1))
	{
		return EMU_KEY_NOT_FOUND;
	}

	if (aesMode == 0x0D || aesMode == 0x11 || aesMode == 0x15)
	{
		aesAfterCore = 1;
	}

	if (needsAES && !aesAfterCore)
	{
		if (aesMode == 0x0F)
		{
			hdSurEncPhase1_D2_0F_11(source);
			hdSurEncPhase2_D2_0F_11(source);
		}
		else if (aesMode == 0x13)
		{
			hdSurEncPhase1_D2_13_15(source);
		}

		struct aes_keys aes;
		aes_set_key(&aes, aesKey);
		aes_decrypt(&aes, source, 16);

		if (aesMode == 0x0F)
		{
			hdSurEncPhase1_D2_0F_11(source);
		}
		else if (aesMode == 0x13)
		{
			hdSurEncPhase2_D2_13_15(source);
		}
	}

	for (i = 0; i < 2; i++)
	{
		memcpy(tmpData, source + i * 8, 8);
		via3_process_dw(tmpData, ident, desKeyIndex);

		if (i != 0)
		{
			pXorVector = source;
		}
		else
		{
			pXorVector = &C1[0];
		}

		for (j = 0; j < 8; j++)
		{
			dw[i * 8 + j] = tmpData[j] ^ pXorVector[j];
		}
	}

	if (needsAES && aesAfterCore)
	{
		if (aesMode == 0x11)
		{
			hdSurEncPhase1_D2_0F_11(dw);
			hdSurEncPhase2_D2_0F_11(dw);
		}
		else if (aesMode == 0x15)
		{
			hdSurEncPhase1_D2_13_15(dw);
		}

		struct aes_keys aes;
		aes_set_key(&aes, aesKey);
		aes_decrypt(&aes, dw, 16);

		if (aesMode == 0x11)
		{
			hdSurEncPhase1_D2_0F_11(dw);
		}

		if (aesMode == 0x15)
		{
			hdSurEncPhase2_D2_13_15(dw);
		}
	}

	if (ident == 0x030B00)
	{
		if (doFinalMix)
		{
			via3_final_mix(dw);
		}

		if (!is_valid_dcw(dw) || !is_valid_dcw(dw + 8))
		{
			return EMU_CHECKSUM_ERROR;
		}
	}

	return EMU_OK;
}

int8_t viaccess_ecm(uint8_t *ecm, uint8_t *dw)
{
	int8_t doFinalMix = 0;

	uint8_t nanoCmd = 0, nanoLen = 0, version = 0, providerKeyLen = 0;
	uint8_t desKeyIndex = 0, aesMode = 0, aesKeyIndex = 0xFF;
	uint16_t i = 0, keySelectPos = 0, ecmLen = SCT_LEN(ecm);
	uint32_t currentIdent = 0;

	for (i = 4; i + 2 < ecmLen; )
	{
		nanoCmd = ecm[i++];
		nanoLen = ecm[i++];

		if (i + nanoLen > ecmLen)
		{
			return EMU_NOT_SUPPORTED;
		}

		switch (nanoCmd)
		{
			case 0x40:
				if (nanoLen < 0x03)
				{
					break;
				}
				version = ecm[i];
				if (nanoLen == 3)
				{
					currentIdent = ((ecm[i] << 16) | (ecm[i + 1] << 8)) | (ecm[i + 2] & 0xF0);
					desKeyIndex = ecm[i + 2] & 0x0F;
					keySelectPos = i + 3;
				}
				else
				{
					currentIdent = (ecm[i] << 16) | (ecm[i + 1] << 8) | ((ecm[i + 2] >> 4) & 0x0F);
					desKeyIndex = ecm[i + 3];
					keySelectPos = i + 4;
				}
				providerKeyLen = nanoLen;
				break;

			case 0x90:
				if (nanoLen < 0x03)
				{
					break;
				}
				version = ecm[i];
				currentIdent = ((ecm[i] << 16) | (ecm[i + 1] << 8)) | (ecm[i + 2] & 0xF0);
				desKeyIndex = ecm[i + 2] & 0x0F;
				keySelectPos = i + 4;
				if ((version == 3) && (nanoLen > 3))
				{
					desKeyIndex = ecm[i + (nanoLen - 4)] & 0x0F;
				}
				providerKeyLen = nanoLen;
				break;

			case 0x80:
				nanoLen = 0;
				break;

			case 0xD2:
				if (nanoLen < 0x02)
				{
					break;
				}
				aesMode = ecm[i];
				aesKeyIndex = ecm[i + 1];
				break;

			case 0xDD:
				nanoLen = 0;
				break;

			case 0xEA:
				if (nanoLen < 0x10)
				{
					break;
				}
				if (version < 2)
				{
					return via1_decrypt(ecm, dw, currentIdent, desKeyIndex);
				}
				else if (version == 2)
				{
					return via26_decrypt(ecm + i, dw, currentIdent, desKeyIndex);
				}
				else if (version == 3)
				{
					doFinalMix = 0;
					if (currentIdent == 0x030B00 && providerKeyLen > 3)
					{
						if (keySelectPos + 2 >= ecmLen)
						{
							break;
						}
						if (ecm[keySelectPos] == 0x05 && ecm[keySelectPos + 1] == 0x67 &&
							(ecm[keySelectPos + 2] == 0x00 || ecm[keySelectPos + 2] == 0x01))
						{
							if (ecm[keySelectPos + 2] == 0x01)
							{
								doFinalMix = 1;
							}
						}
						else
						{
							break;
						}
					}

					return via3_decrypt(ecm + i, dw, currentIdent, desKeyIndex, aesKeyIndex, aesMode, doFinalMix);
				}
				break;

			default:
				break;
		}

		i += nanoLen;
	}

	return EMU_NOT_SUPPORTED;
}

// Viaccess EMM EMU

int8_t viaccess_emm(uint8_t *emm, uint32_t *keysAdded)
{
	uint8_t nanoCmd = 0, subNanoCmd = 0, *tmp;
	uint8_t ecmKeyCount = 0, emmKeyIndex = 0, aesMode = 0x0D;
	uint8_t nanoLen = 0, subNanoLen = 0, haveEmmXorKey = 0, haveNewD0 = 0;
	uint8_t ecmKeys[6][16], keyD0[2], emmKey[16], emmXorKey[16], provName[17];

	uint16_t i = 0, j = 0, k = 0, emmLen = SCT_LEN(emm);
	uint32_t ui1, ui2, ui3, ecmKeyIndex[6], provider = 0, ecmProvider = 0;

	char keyName[EMU_MAX_CHAR_KEYNAME], keyValue[36];
	struct aes_keys aes;

	memset(keyD0, 0, 2);
	memset(ecmKeyIndex, 0, sizeof(uint32_t) * 6);

	for (i = 3; i + 2 < emmLen; )
	{
		nanoCmd = emm[i++];
		nanoLen = emm[i++];

		if (i + nanoLen > emmLen)
		{
			return EMU_NOT_SUPPORTED;
		}

		switch (nanoCmd)
		{
			case 0x90:
			{
				if (nanoLen < 3)
				{
					break;
				}

				ui1 = emm[i + 2];
				ui2 = emm[i + 1];
				ui3 = emm[i];
				provider = (ui1 | (ui2 << 8) | (ui3 << 16));

				if (provider == 0x00D00040)
				{
					ecmProvider = 0x030B00;
				}
				else
				{
					return EMU_NOT_SUPPORTED;
				}
				break;
			}

			case 0xD2:
			{
				if (nanoLen < 2)
				{
					break;
				}

				emmKeyIndex = emm[i + 1];
				break;
			}

			case 0x41:
			{
				if (nanoLen < 1)
				{
					break;
				}

				if (!get_key(emmKey, provider, 'M', emmKeyIndex, 16, 1))
				{
					return EMU_KEY_NOT_FOUND;
				}

				memset(provName, 0, 17);
				memset(emmXorKey, 0, 16);

				k = nanoLen < 16 ? nanoLen : 16;

				memcpy(provName, &emm[i], k);
				aes_set_key(&aes, (char *)emmKey);
				aes_decrypt(&aes, emmXorKey, 16);

				for (j = 0; j < 16; j++)
				{
					provName[j] ^= emmXorKey[j];
				}
				provName[k] = 0;

				if (strcmp((char *)provName, "TNTSAT") != 0 &&
					strcmp((char *)provName, "TNTSATPRO") != 0 &&
					strcmp((char *)provName, "CSAT V") != 0)
				{
					return EMU_NOT_SUPPORTED;
				}

				break;
			}

			case 0xBA:
			{
				if (nanoLen < 2)
				{
					break;
				}

				get_key(keyD0, ecmProvider, 'D', 0, 2, 0);

				ui1 = (emm[i] << 8) | emm[i + 1];

				if( (uint32_t)((keyD0[0] << 8) | keyD0[1]) < ui1 || (keyD0[0] == 0x00 && keyD0[1] == 0x00))
				{
					keyD0[0] = emm[i];
					keyD0[1] = emm[i + 1];
					haveNewD0 = 1;
					break;
				}

				return EMU_OK;
			}

			case 0xBC:
			{
				break;
			}

			case 0x43:
			{
				if (nanoLen < 16)
				{
					break;
				}

				memcpy(emmXorKey, &emm[i], 16);
				haveEmmXorKey = 1;

				break;
			}

			case 0x44:
			{
				if (nanoLen < 3)
				{
					break;
				}

				if (!haveEmmXorKey)
				{
					memset(emmXorKey, 0, 16);
				}

				tmp = (uint8_t *)malloc(((nanoLen / 16) + 1) * 16 * sizeof(uint8_t));
				if (tmp == NULL)
				{
					return EMU_OUT_OF_MEMORY;
				}

				memcpy(tmp, &emm[i], nanoLen);
				aes_set_key(&aes, (char *)emmKey);

				for (j = 0; j < nanoLen; j += 16)
				{
					aes_decrypt(&aes, emmXorKey, 16);

					for (k = 0; k < 16; k++)
					{
						tmp[j + k] ^= emmXorKey[k];
					}
				}

				memcpy(&emm[i - 2], tmp, nanoLen);
				free(tmp);
				nanoLen = 0;
				i -= 2;
				break;
			}

			case 0x68:
			{
				if (ecmKeyCount > 5)
				{
					break;
				}

				for (j = i; j + 2 < i + nanoLen; )
				{
					subNanoCmd = emm[j++];
					subNanoLen = emm[j++];

					if (j + subNanoLen > i + nanoLen)
					{
						break;
					}

					switch (subNanoCmd)
					{
						case 0xD2:
						{
							if (nanoLen < 2)
							{
								break;
							}

							aesMode = emm[j];
							emmKeyIndex = emm[j + 1];
							break;
						}

						case 0x01:
						{
							if(nanoLen < 17)
							{
								break;
							}

							ecmKeyIndex[ecmKeyCount] = emm[j];
							memcpy(&ecmKeys[ecmKeyCount], &emm[j + 1], 16);

							if (!get_key(emmKey, provider, 'M', emmKeyIndex, 16, 1))
							{
								break;
							}

							if (aesMode == 0x0F || aesMode == 0x11)
							{
								hdSurEncPhase1_D2_0F_11(ecmKeys[ecmKeyCount]);
								hdSurEncPhase2_D2_0F_11(ecmKeys[ecmKeyCount]);
							}
							else if (aesMode == 0x13 || aesMode == 0x15)
							{
								hdSurEncPhase1_D2_13_15(ecmKeys[ecmKeyCount]);
							}

							aes_set_key(&aes, (char *)emmKey);
							aes_decrypt(&aes, ecmKeys[ecmKeyCount], 16);

							if (aesMode == 0x0F || aesMode == 0x11)
							{
								hdSurEncPhase1_D2_0F_11(ecmKeys[ecmKeyCount]);
							}
							else if (aesMode == 0x13 || aesMode == 0x15)
							{
								hdSurEncPhase2_D2_13_15(ecmKeys[ecmKeyCount]);
							}

							ecmKeyCount++;
							break;
						}

						default:
							break;
					}

					j += subNanoLen;
				}
				break;
			}

			case 0xF0:
			{
				if (nanoLen != 4)
				{
					break;
				}

				ui1 = ((emm[i + 2] << 8) | (emm[i + 1] << 16) | (emm[i] << 24) | emm[i + 3]);

				if (ccitt32_crc(emm + 3, emmLen - 11) != ui1)
				{
					return EMU_CHECKSUM_ERROR;
				}

				if (haveNewD0)
				{
					SAFE_MUTEX_LOCK(&emu_key_data_mutex);
					emu_set_key('V', ecmProvider, "D0", keyD0, 2, 1, NULL, NULL);

					for (j = 0; j < ecmKeyCount; j++)
					{
						snprintf(keyName, EMU_MAX_CHAR_KEYNAME, "E%X", ecmKeyIndex[j]);
						emu_set_key('V', ecmProvider, keyName, ecmKeys[j], 16, 1, NULL, NULL);

						(*keysAdded)++;
						cs_hexdump(0, ecmKeys[j], 16, keyValue, sizeof(keyValue));
						cs_log("Key found in EMM: V %06X %s %s", ecmProvider, keyName, keyValue);
					}
					SAFE_MUTEX_UNLOCK(&emu_key_data_mutex);
				}
				break;
			}

			default:
				break;
		}

		i += nanoLen;
	}

	return EMU_OK;
}

#endif // WITH_EMU