/* * * Copyright (c) Sigma Designs, Inc. 2006. All rights reserved. * *//* * *********************************************************** * This is UGLY, #including this file isnt the way to go, but * it's a fast way of cleaning play_psfdemux.c * The best approach will be to convert this into a library * and merge it with RMDRM lib. * *********************************************************** *//**   @file psfdemux_drm.c   @brief drm functionality for play_psfdemux	   @author Aurelia Popa-Radu   @ingroup dccsamplecode*/#include "../samples/sample_os.h"#define ALLOW_OS_CODE 1#include "../dcc/include/dcc.h"#include "../samples/common.h"#include "psfdemux_common.h"#if (ALLOW_LIBRMARIB)#include <dlfcn.h>#endif#if 0#define LOCALDBG ENABLE#else#define LOCALDBG DISABLE#endif#if 0#define CALLDBG ENABLE#else#define CALLDBG DISABLE#endif#if 0#define KEYDBG ENABLE#else#define KEYDBG DISABLE#endif/**************************** application types *******************************/RMstatus DvbKeyInband(struct context_per_task *context, RMuint8 ecm_entry, enum EMhwlibScramblingBits scrambling, RMuint8 *pkey, RMuint32 key_size){	RMuint32 size;	RMuint32 offset = (ecm_entry == ECM0_SECTION_ENTRY) ? 0 : 1;	struct DemuxTask_InbandKeyChange_type ibc;		RUAGetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_InbandFifoWritableSize, &size, sizeof(size));	if (size == 0) {		RMDBGLOG((LOCALDBG, "********************** insufficient InbandFifoWritableSize\n"));		return RM_INSUFFICIENT_SIZE;	}		/* set the key using inband command */	if (scrambling == EMhwlibScramblingBits_10) {		ibc.key_index = context->key_index[(offset << 1) + 0];		RMDBGLOG((ENABLE, "********************** DvbKeyInband Even *********************************\n"));	}	else if (scrambling == EMhwlibScramblingBits_11) {		ibc.key_index = context->key_index[(offset << 1) + 1];		RMDBGLOG((ENABLE, "********************** DvbKeyInband Odd *********************************\n"));	}	else if (scrambling == EMhwlibScramblingBits_10_11) {		ibc.key_index = context->key_index[(offset << 1) + 0];		RMDBGLOG((ENABLE, "********************** DvbKeyInband Even+Odd *********************************\n"));	}	{		struct DemuxTask_DVBCSAKey_type dvb_key;		dvb_key.key_index = ibc.key_index;		RMMemcpy(dvb_key.key, pkey, key_size);		/* do DVBCSA conformance mechanism */		dvb_key.key[0] = (dvb_key.key[1] + dvb_key.key[2] + dvb_key.key[3])%256;		dvb_key.key[4] = (dvb_key.key[5] + dvb_key.key[6] + dvb_key.key[7])%256;		RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_DVBCSAKey, &dvb_key, sizeof(dvb_key), 0);	}	//fprintf(stderr, "DvbKeyInband key_index=%ld, cipher_index=%ld\n", ibc.key_index, context->cipher_index[offset]);		/* set key for entry 0 in CipherTable */	ibc.cipher_index = context->cipher_index[offset];	ibc.scrambling = scrambling;	ibc.offset_control = EMhwlibInbandOffset_Ignore;	ibc.offset_value = 0;	return RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_InbandKeyChange, &ibc, sizeof(ibc), 0);}RMstatus DvbKeyOutband(struct context_per_task *context, RMuint8 ecm_entry, enum EMhwlibScramblingBits scrambling, RMuint8 *pkey, RMuint32 key_size){	RMuint32 offset = (ecm_entry == ECM0_SECTION_ENTRY) ? 0 : 1;	struct DemuxTask_DVBCSAKey_type dvb_key;	struct DemuxTask_OutbandKeyChange_type outband;		/* set the key using outband command */	if (scrambling == EMhwlibScramblingBits_10) {		outband.key_index = context->key_index[(offset << 1) + 0];		RMDBGLOG((ENABLE, "********************** DvbKeyOutband Even *********************************\n"));	}	else if (scrambling == EMhwlibScramblingBits_11) {		outband.key_index = context->key_index[(offset << 1) + 1];		RMDBGLOG((ENABLE, "********************** DvbKeyOutband Odd *********************************\n"));	}	else if (scrambling == EMhwlibScramblingBits_10_11) {		outband.key_index = context->key_index[(offset << 1) + 0];		RMDBGLOG((ENABLE, "********************** DvbKeyOutband Even+Odd *********************************\n"));	}	dvb_key.key_index = outband.key_index;	RMMemcpy(dvb_key.key, pkey, key_size);	/* do DVBCSA conformance mechanism */	dvb_key.key[0] = (dvb_key.key[1] + dvb_key.key[2] + dvb_key.key[3])%256;	dvb_key.key[4] = (dvb_key.key[5] + dvb_key.key[6] + dvb_key.key[7])%256;	RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_DVBCSAKey, &dvb_key, sizeof(dvb_key), 0);		/* set key index for entry 0 in CipherTable */	outband.cipher_index = context->cipher_index[offset];	outband.cipher_type = EMhwlibCipher_DVBCSA;	outband.scrambling = scrambling;	return RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_OutbandKeyChange, &outband, sizeof(outband), 0);}RMstatus AESKeyInband(struct context_per_task *context, RMuint8 ecm_entry, enum EMhwlibScramblingBits scrambling, RMuint8 *pkey, RMuint8 *piv, RMuint32 key_size){	RMuint32 size;	struct DemuxTask_InbandKeyChange_type ibc;	RMuint32 offset = (ecm_entry == ECM0_SECTION_ENTRY) ? 0 : 1;	struct DemuxTask_AESKey_type aes_key;		RUAGetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_InbandFifoWritableSize, &size, sizeof(size));	if (size == 0) {		RMDBGLOG((LOCALDBG, "********************** insufficient InbandFifoWritableSize\n"));		return RM_INSUFFICIENT_SIZE;	}		/* set the key using inband command */	// assuming the first two keys are associated with cipher 0	ibc.cipher_index = 0;	if (scrambling == EMhwlibScramblingBits_10) {		ibc.key_index = context->key_index[(offset << 1) + 0];		RMDBGLOG((KEYDBG, "AESKeyInband Even cipher_index %d key_index %d\n", ibc.cipher_index, ibc.key_index));	}	else if (scrambling == EMhwlibScramblingBits_11) {		ibc.key_index = context->key_index[(offset << 1) + 1];		RMDBGLOG((KEYDBG, "AESKeyInband Odd cipher_index %d key_index %d\n", ibc.cipher_index, ibc.key_index));	}	else if (scrambling == EMhwlibScramblingBits_10_11) {		ibc.key_index = context->key_index[(offset << 1) + 0];		RMDBGLOG((KEYDBG, "AESKeyInband Even+Odd cipher_index %d key_index %d\n", ibc.cipher_index, ibc.key_index));	}	aes_key.key_index = ibc.key_index;	aes_key.key_size = key_size; // 16 bytes	RMMemcpy(aes_key.key, pkey, key_size);	RMMemcpy(aes_key.iv, piv, key_size);	RMDBGLOG((KEYDBG, "AESKey key_index %d key_size %d\n", aes_key.key_index, aes_key.key_size));	RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_AESKey, &aes_key, sizeof(aes_key), 0);		/* set key for entry 0 in CipherTable */	ibc.cipher_index = context->cipher_index[offset];	ibc.scrambling = scrambling;	ibc.offset_control = EMhwlibInbandOffset_Ignore;	ibc.offset_value = 0;	RMDBGLOG((KEYDBG, "Key change cipher_index %d key_index %d scrambling bits %d  inband no offset\n\n", ibc.cipher_index, ibc.key_index, ibc.scrambling));	return RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_InbandKeyChange, &ibc, sizeof(ibc), 0);}RMstatus AESKeyOutband(struct context_per_task *context, RMuint8 ecm_entry, enum EMhwlibScramblingBits scrambling, RMuint8 *pkey, RMuint8 *piv, RMuint32 key_size){	RMuint32 offset = (ecm_entry == ECM0_SECTION_ENTRY) ? 0 : 1;	struct DemuxTask_AESKey_type aes_key;	struct DemuxTask_OutbandKeyChange_type outband;		/* set the key using outband command */	if (scrambling == EMhwlibScramblingBits_10) {		outband.key_index = context->key_index[(offset << 1) + 0];		RMDBGLOG((KEYDBG, "********************** AesKeyOutband Even *********************************\n"));	}	else if (scrambling == EMhwlibScramblingBits_11) {		outband.key_index = context->key_index[(offset << 1) + 1];		RMDBGLOG((KEYDBG, "********************** AesKeyOutband Odd *********************************\n"));	}	else if (scrambling == EMhwlibScramblingBits_10_11) {		outband.key_index = context->key_index[(offset << 1) + 0];		RMDBGLOG((KEYDBG, "********************** AesKeyOutband Even+Odd *********************************\n"));	}	aes_key.key_index = outband.key_index;	aes_key.key_size = key_size; // 16 bytes	RMMemcpy(aes_key.key, pkey, key_size);	RMMemcpy(aes_key.iv, piv, key_size);	RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_AESKey, &aes_key, sizeof(aes_key), 0);		/* set key index for entry 0 in CipherTable */	outband.cipher_index = context->cipher_index[offset];	outband.cipher_type = EMhwlibCipher_AES;	outband.scrambling = scrambling;	return RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_OutbandKeyChange, &outband, sizeof(outband), 0);}/* ############## AES_CBC_PRECIPHER CODE BEGIN ############## */RMstatus AESKeyPrecipherInband(struct RUA *Context_RUA,RMuint32 Context_demux_task,enum EMhwlibScramblingBits scrambling, RMuint8 *pkey, RMuint8 *piv, RMuint32 key_size,RMuint32 inband_state){	RMstatus err;	RMuint32 size = 0;	struct DemuxTask_InbandKeyChange_type ibc;	struct DemuxTask_AESKey_type aes_key;	struct DemuxTask_PreprocessCipher_type ppc;	/*********** write AES Key *************************/	aes_key.key_index = (inband_state&1)?1:0;	aes_key.key_size = key_size;	RMMemcpy(aes_key.key,pkey, key_size);	RMMemcpy(aes_key.iv ,piv , key_size);                                                                                                                             	err=RUASetProperty(Context_RUA, Context_demux_task, RMDemuxTaskPropertyID_AESKey, &aes_key, sizeof(aes_key), 0);	if (RMFAILED(err)){		RMDBGLOG((ENABLE, "AESKeyPrecipherInband :error AESKey\n"));		return RM_ERROR;	}	/*********** Set PreprocessCipher *******************/	if (inband_state == 0) {		ppc.enable = TRUE;		ppc.cipher_index = 0;		err = RUASetProperty(Context_RUA, Context_demux_task, RMDemuxTaskPropertyID_PreprocessCipher, &ppc, sizeof(ppc), 0);		if (RMFAILED(err)) {			RMDBGLOG((ENABLE, "AESKeyPrecipherInband:error PreprocessCipher\n"));			return RM_ERROR;		}	}	/********** InbandFifoWritableSize *****************/	err = RUAGetProperty(Context_RUA, Context_demux_task, RMDemuxTaskPropertyID_InbandFifoWritableSize, &size, sizeof(size));	if (size == 0 || RMFAILED(err)) {		RMDBGLOG((ENABLE, "********************** insufficient InbandFifoWritableSize\n"));		return RM_ERROR;	}		/*** Inband Key Change: set key_index 0 or 1 for cipher entry 0 in CipherTable ***/	ibc.key_index = (inband_state & 1);	ibc.cipher_index = 0;	ibc.scrambling = scrambling;	ibc.offset_control = EMhwlibInbandOffset_Ignore;	ibc.offset_value = 0;	err = RUASetProperty(Context_RUA, Context_demux_task, RMDemuxTaskPropertyID_InbandKeyChange, &ibc, sizeof(ibc), 0);		if (RMFAILED(err)) {		RMDBGLOG((ENABLE, "AESKeyPrecipherInband :error InbandKeyChange"));		return RM_ERROR;	}		return RM_OK;}/* ############## AES_CBC_PRECIPHER CODE END ############### *//************************************************************************ * Use Inband command through demuxhw writing multi2 key into table ************************************************************************/RMstatus Multi2KeyInband(struct context_per_task *context, RMuint32 index, enum key_type key_type){	RMuint32	size;	RMstatus	err = RM_OK;	struct		DemuxTask_InbandKeyChange_type ibc;	struct		arib_key_band *ecm_key;		RUAGetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_InbandFifoWritableSize, &size, sizeof(size));	if (size == 0) {		RMDBGLOG((LOCALDBG, "********************** insufficient InbandFifoWritableSize\n"));		return RM_INSUFFICIENT_SIZE;	}		ecm_key = &(context->arib_key_table[index]);	/*	 * Reuse the already allocated entry in the Multi2Table	 */	ibc.key_index = ecm_key->multi2_key.key_index;	/*	 * Setup Multi2Table for demux task	 */	err = RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_Multi2Key, &(ecm_key->multi2_key), sizeof(struct DemuxTask_Multi2Key_type), 0);	if (RMFAILED(err)) {		RMDBGLOG((ENABLE, "Error RMDemuxTaskPropertyID_Multi2Key\n"));		return(err);	}		/*	 * Already setup ciphertable index?	 */	if (!ecm_key->ciphertable_done) {		/*		 * scrambling = ? offset_control = ? offset_value = ?		 */		if (key_type == EVEN_KEY) {			ecm_key->scrambling = EMhwlibScramblingBits_10;		}		else {			ecm_key->scrambling = EMhwlibScramblingBits_11;		}		ecm_key->offset_control = EMhwlibInbandOffset_Absolute;		ecm_key->offset_value = context->file_byte_counter;		/*		 * Set key for entry #emc_key->index_cipher_table in CipherTable		 */		ibc.cipher_index = ecm_key->index_cipher_table;		ibc.scrambling = ecm_key->scrambling;		ibc.offset_control = ecm_key->offset_control;		ibc.offset_value = ecm_key->offset_value;		err = RUASetProperty(context->pRUA, context->demux_task, RMDemuxTaskPropertyID_InbandKeyChange, &ibc, sizeof(ibc), 0);		if (RMFAILED(err)) {			RMDBGLOG((ENABLE, "Error RMDemuxTaskPropertyID_InbandKeyChange\n"));			return(err);		}		ecm_key->ciphertable_done = TRUE;