1017 lines
44 KiB
C
1017 lines
44 KiB
C
/*
|
|
******************************************************************************
|
|
* INTERPEAK SOURCE FILE
|
|
*
|
|
* Document no: @(#) $Name: VXWORKS_ITER40_2019102207 $ $RCSfile: sec_dcl_ipfreescale.c,v $ $Revision: 1.7.12.1 $
|
|
* $Source: /home/interpeak/CVSRoot/ipfreescale/sec4/sec_dcl_ipfreescale.c,v $
|
|
* $Author: jsheng $
|
|
* $State: Exp $ $Locker: $
|
|
*
|
|
* INTERPEAK_COPYRIGHT_STRING
|
|
******************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* Ipfreescale extensions to the Freescale Netcomm SEC/DCL library.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <sec_ext.h>
|
|
#include <error_ext.h>
|
|
#include <sec_dcl_cmd.h>
|
|
#include <sec_dcl.h>
|
|
#include <sec_dcl_ipfreescale.h>
|
|
#include <sec_dcl_api_ipfreescale.h>
|
|
|
|
void PrintDecodeDescriptor(uint32_t* buffer, char* tag);
|
|
void PrintDecodePDB(uint32_t* buf_p, uint32_t pdbType);
|
|
|
|
extern t_Handle h_Sec4;
|
|
|
|
#define __ERR_MODULE__ MODULE_SEC
|
|
|
|
|
|
t_Handle SEC_DCL_InitJobDesc(t_Handle h_SecDcl,
|
|
t_JobDescParam *param)
|
|
{
|
|
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
|
|
t_Handle* h_Desc;
|
|
|
|
uint32_t length;
|
|
uint32_t buffer[MAX_DESC_LENGTH];
|
|
/* Using MAX_DESC_LENGTH instead of MaxJobDescLen in order to keep it simple */
|
|
|
|
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
|
|
SANITY_CHECK_EXIT(param,E_NULL_POINTER);
|
|
|
|
switch(param->jobTypeId)
|
|
{
|
|
case e_DCL_JOB_RANDNUM:
|
|
length = InitRandNumJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->outDataBytes, param->outData);
|
|
break;
|
|
case e_DCL_JOB_MD5_DIGEST:
|
|
length = InitMd5DigestJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->outDataBytes,
|
|
param->inData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_SHA1_DIGEST:
|
|
length = InitSha1DigestJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->outDataBytes,
|
|
param->inData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_MD5_HMAC:
|
|
length = InitMd5HmacJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_SHA1_HMAC:
|
|
length = InitSha1HmacJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_DES_CBC_ENCRYPT:
|
|
length = InitDesCbcEncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->inCtxData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_DES_CBC_DECRYPT:
|
|
length = InitDesCbcDecryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->inCtxData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_DES_ECB_ENCRYPT:
|
|
length = InitDesEcbEncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_DES_ECB_DECRYPT:
|
|
length = InitDesEcbDecryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_TDES_CBC_ENCRYPT:
|
|
length = InitTdesCbcEncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->inCtxData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_TDES_CBC_DECRYPT:
|
|
length = InitTdesCbcDecryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->inCtxData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_TDES_ECB_ENCRYPT:
|
|
length = InitTdesEcbEncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_TDES_ECB_DECRYPT:
|
|
length = InitTdesEcbDecryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_AES_CBC_ENCRYPT:
|
|
length = InitAesCbcEncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outCtxDataBytes,
|
|
param->inData, param->keyData, param->inCtxData, param->outData, param->outCtxData);
|
|
break;
|
|
case e_DCL_JOB_AES_CBC_DECRYPT:
|
|
length = InitAesCbcDecryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outCtxDataBytes,
|
|
param->inData, param->keyData, param->inCtxData, param->outData, param->outCtxData);
|
|
break;
|
|
case e_DCL_JOB_AES_ECB_ENCRYPT:
|
|
length = InitAesEcbEncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_AES_ECB_DECRYPT:
|
|
length = InitAesEcbDecryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_RC4_ENCRYPT:
|
|
length = InitRc4EncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->inCtxDataBytes, param->outCtxDataBytes,
|
|
param->inData, param->keyData, param->inCtxData, param->outData, param->outCtxData);
|
|
break;
|
|
case e_DCL_JOB_MODEXP:
|
|
length = InitModExpJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->modDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->modData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_CCMP_ENCRYPT:
|
|
length = InitCcmpEncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->AADDataBytes, param->MICDataBytes,
|
|
param->inCtxDataBytes, param->outDataBytes,
|
|
param->inData, param->keyData, param->AADData, param->inMICData, param->inCtxData, param->outData);
|
|
break;
|
|
case e_DCL_JOB_CHKSUM_CRC:
|
|
length = InitCRCJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->inData, param->outDataBytes, param->outData,
|
|
param->inCtxDataBytes, param->inCtxData, param->keyData, param->options);
|
|
break;
|
|
case e_DCL_JOB_MOVE_DATA:
|
|
length = InitMoveDataJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->inData, param->outData, param->options);
|
|
break;
|
|
case e_DCL_JOB_AESCCM_ENCRYPT:
|
|
length = InitAesCcmEncryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->AADDataBytes, param->MICDataBytes,
|
|
param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData,
|
|
param->AADData, param->inMICData, param->outMICData, param->inCtxData, param->outData, param->options);
|
|
break;
|
|
case e_DCL_JOB_AESCCM_DECRYPT:
|
|
length = InitAesCcmDecryptJobDesc(buffer, p_SecDcl->ptrSize,
|
|
param->inDataBytes, param->keyDataBytes, param->AADDataBytes, param->MICDataBytes,
|
|
param->inCtxDataBytes, param->outDataBytes, param->inData, param->keyData,
|
|
param->AADData, param->inMICData, param->outMICData, param->inCtxData, param->outData, param->options);
|
|
break;
|
|
default:
|
|
/* Not supported jobId */
|
|
return NULL;
|
|
}
|
|
|
|
h_Desc = CreateDescObject(p_SecDcl,length,buffer);
|
|
|
|
return h_Desc;
|
|
}
|
|
|
|
t_Handle SEC_DCL_InitIpsecJobDesc(t_Handle h_SecDcl,
|
|
t_IpsecJobDescParam *param)
|
|
{
|
|
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
|
|
|
|
uint32_t length;
|
|
uint32_t buffer[MAX_DESC_LENGTH];
|
|
/* Using MAX_DESC_LENGTH instead of MaxJobDescLen in order to keep it simple */
|
|
|
|
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
|
|
SANITY_CHECK_EXIT(param,E_NULL_POINTER);
|
|
|
|
length = InitIpsecJobDesc(buffer, p_SecDcl->ptrSize, param);
|
|
return CreateDescObject(p_SecDcl,length,buffer);
|
|
}
|
|
|
|
#ifdef DBG
|
|
#define PRINT_DATA_LIMIT 128 /* Limit print of data referenced by descriptors to this many bytes */
|
|
/*
|
|
* Prints descriptor starting at buffer.
|
|
* An optional tag (string) is prepended each decoded descriptor word.
|
|
*/
|
|
void
|
|
PrintDecodeDescriptor(uint32_t* buffer, char* tag)
|
|
{
|
|
int i,j;
|
|
uint32_t ctype, opType, opId, descLen, aai;
|
|
int next_data_is_pointer=0;
|
|
int next_data_is_immediate=0;
|
|
int next_data_is_pdb=0;
|
|
int next_data_is_sgt=0;
|
|
int next_data_size=0;
|
|
int startIndex=0;
|
|
int pdbIndex=0;
|
|
uint32_t pdbType=0;
|
|
int ptrSize;
|
|
uint32_t shr_desc_addr = NULL;
|
|
char printBuf[(2 * PRINT_DATA_LIMIT) + 128];
|
|
int printBufIx=0;
|
|
|
|
/* Pointers can be 1 or 2 words */
|
|
ptrSize = (int) SEC_GetPtrSize(h_Sec4) / sizeof(uint32_t);
|
|
|
|
descLen = JOB_DESC_HDR_LENGTH_GET(buffer[0]);
|
|
printf("\n");
|
|
for(i=0;i<descLen;i++)
|
|
{
|
|
/* Print optional tag */
|
|
if(tag != NULL) printf("%s", tag);
|
|
|
|
printf("[%d]\t:0x%08x : ", i, buffer[i]);
|
|
/* If current word doesn't contain data, decode content */
|
|
if((next_data_is_pointer == 0) &&
|
|
(next_data_is_immediate == 0) &&
|
|
(next_data_is_pdb == 0) &&
|
|
(next_data_is_sgt == 0))
|
|
{
|
|
ctype = buffer[i] >> 27; /* Command type */
|
|
switch (ctype)
|
|
{
|
|
case CMD_JOB_DESC_HDR:
|
|
printf("CMD_JOB_DESC_HDR: ");
|
|
printf("(DESC_LEN=%d)", descLen);
|
|
startIndex = (buffer[i] >> 16) & 0x3f;
|
|
/* Check if it uses a shared descriptor */
|
|
if((buffer[i] & JOB_DESC_HDR_SHR) == JOB_DESC_HDR_SHR)
|
|
{
|
|
if (buffer[i] & JOB_DESC_HDR_REO) printf("(REO)");
|
|
printf("(SHR_DESC_LEN=%d)", startIndex);
|
|
next_data_is_pointer = ptrSize;
|
|
next_data_size = startIndex * sizeof(uint32_t);
|
|
/* Decode the shared descriptor that is pointed out in next word(s)*/
|
|
shr_desc_addr = (uint32_t *)XX_PhysToVirt((physAddress_t) (*(buffer + i + 2))); /* TODO use correct actual ptr length */
|
|
PrintDecodeDescriptor(shr_desc_addr, " shrDesc");
|
|
}
|
|
else
|
|
{ /* This descriptor doesn't use shared descriptor */
|
|
printf("startIndex=%d ", startIndex);
|
|
if(startIndex > 1)
|
|
{
|
|
next_data_is_pdb = startIndex-1;
|
|
/* Remember pdbIndex to decode once we now how */
|
|
pdbIndex = i+1;
|
|
}
|
|
}
|
|
break;
|
|
case CMD_SHR_DESC_HDR:
|
|
printf("CMD_SHR_DESC_HDR: ");
|
|
startIndex = (buffer[i] >> 16) & 0x3f;
|
|
printf("startIndex=%d ", startIndex);
|
|
if(startIndex > 1)
|
|
{
|
|
next_data_is_pdb = startIndex-1;
|
|
/* Remember pdbIndex to decode once we now how */
|
|
pdbIndex = i+1;
|
|
}
|
|
printf("desclen=%d", descLen);
|
|
break;
|
|
case CMD_SEQ_IN_PTR:
|
|
printf("CMD_SEQ_IN_PTR:");
|
|
if (buffer[i] & SEQ_IN_PTR_RBS) printf("(RBS)");
|
|
if (buffer[i] & SEQ_IN_PTR_INL) printf("(INL)");
|
|
if (buffer[i] & SEQ_IN_PTR_SGT) printf("(SGT)");
|
|
if (buffer[i] & SEQ_IN_PTR_PRE) printf("(PRE)");
|
|
if (buffer[i] & SEQ_IN_PTR_EXT) printf("(EXT)");
|
|
if (buffer[i] & SEQ_IN_PTR_RTO) printf("(RTO)");
|
|
if (buffer[i] & SEQ_IN_PTR_JRD) printf("(JRD)");
|
|
if (!(buffer[i] & SEQ_IN_PTR_RTO) && !(buffer[i] & SEQ_IN_PTR_PRE))
|
|
{
|
|
next_data_is_pointer = ptrSize;
|
|
next_data_size = SEQ_IN_PTR_LENGTH(buffer[i]);
|
|
}
|
|
printf("(length = 0x%x)", SEQ_IN_PTR_LENGTH(buffer[i]));
|
|
break;
|
|
case CMD_SEQ_OUT_PTR:
|
|
printf("CMD_SEQ_OUT_PTR:");
|
|
if (buffer[i] & SEQ_OUT_PTR_SGT) printf("(SGT)");
|
|
if (buffer[i] & SEQ_OUT_PTR_PRE) printf("(PRE)");
|
|
if (buffer[i] & SEQ_OUT_PTR_EXT) printf("(EXT)");
|
|
if (buffer[i] & SEQ_OUT_PTR_RTO) printf("(RTO)");
|
|
if (!(buffer[i] & SEQ_OUT_PTR_RTO))
|
|
{
|
|
next_data_is_pointer = ptrSize;
|
|
next_data_size = SEQ_OUT_PTR_LENGTH(buffer[i]);
|
|
}
|
|
printf("(length = 0x%x)", SEQ_OUT_PTR_LENGTH(buffer[i]));
|
|
break;
|
|
case CMD_KEY:
|
|
printf("CMD_KEY: ");
|
|
switch (buffer[i] & KEY_CLASS_DST_MASK)
|
|
{
|
|
case KEY_CLASS_1_DST_REGISTER: printf("(KEY_CLASS_1_DST_REGISTER)"); break;
|
|
case KEY_CLASS_2_DST_REGISTER: printf("(KEY_CLASS_2_DST_REGISTER)"); break;
|
|
case KEY_CLASS_1_DST_PKHA_E_MEM: printf("(KEY_CLASS_1_DST_PKHA_E_MEM)"); break;
|
|
case KEY_CLASS_1_DST_AFHA_SBOX: printf("(KEY_CLASS_1_DST_AFHA_SBOX)"); break;
|
|
case KEY_CLASS_1_DST_MDHA_SPLIT: printf("(KEY_CLASS_1_DST_MDHA_SPLIT)"); break;
|
|
case KEY_CLASS_2_DST_MDHA_SPLIT: printf("(KEY_CLASS_2_DST_MDHA_SPLIT)"); break;
|
|
default: printf("(undecoded destination)"); break;
|
|
}
|
|
/* Black key info */
|
|
switch(buffer[i] & KEY_ENC_EKT_TK_MASK)
|
|
{
|
|
case KEY_ENC_ON_EKT_AES_CCM_TK_ON: printf("(KEY_ENC_ON_EKT_AES_CCM_TK_ON)"); break;
|
|
case KEY_ENC_ON_EKT_AES_ECB_TK_ON: printf("(KEY_ENC_ON_EKT_AES_ECB_TK_ON)"); break;
|
|
case KEY_ENC_ON_EKT_AES_ECB_TK_OFF: printf("(KEY_ENC_ON_EKT_AES_ECB_TK_OFF)"); break;
|
|
case KEY_ENC_ON_EKT_AES_CCM_TK_OFF: printf("(KEY_ENC_ON_EKT_AES_CCM_TK_OFF)"); break;
|
|
case KEY_ENC_OFF_EKT_UNUSED_TK_UNUSED: printf("(KEY_ENC_OFF_EKT_UNUSED_TK_UNUSED)"); break;
|
|
default: printf("(undecoded black key info)"); break;
|
|
}
|
|
if((buffer[i] & KEY_NWB) != 0)
|
|
printf("(KEY_NWB)");
|
|
/* Immediate data? */
|
|
if (!(buffer[i] & KEY_IMM))
|
|
{
|
|
next_data_is_pointer=ptrSize;
|
|
next_data_size = KEY_LENGTH(buffer[i]);
|
|
}
|
|
else
|
|
{
|
|
printf("(IMM data)");
|
|
next_data_is_immediate = ((KEY_LENGTH(buffer[i])) / sizeof(uint32_t)) + (((KEY_LENGTH(buffer[i])) % sizeof(uint32_t))?1:0);
|
|
next_data_size = next_data_is_immediate * sizeof(uint32_t);
|
|
|
|
}
|
|
break;
|
|
case CMD_OPERATION:
|
|
opType = buffer[i] & ALG_OP_TYPE_MASK;
|
|
opId = buffer[i] & ALG_OP_ID_MASK;
|
|
aai = buffer[i] & ALG_OP_AAI_MASK;
|
|
printf("CMD_OPERATION: ");
|
|
switch(opType)
|
|
{
|
|
case PKHA_OP_TYPE:
|
|
switch (buffer[i] & PKHA_OP_MODE_MASK)
|
|
{
|
|
case PKHA_OP_MODE_MOD_EXP_IM_B: printf("(PKHA_OP_MODE_MOD_EXP_IM_B)"); break;
|
|
case PKHA_OP_MODE_MOD_EXP_B: printf("(PKHA_OP_MODE_MOD_EXP_B)"); break;
|
|
default: printf("Undecoded PKHA_OP_MODE)"); break;
|
|
}
|
|
break;
|
|
case ALG_OP_TYPE_CLASS_1:
|
|
switch(opId)
|
|
{
|
|
case ALG_OP_ID_RNG:
|
|
printf("(ALG_OP_ID_RNG) ");
|
|
break;
|
|
case ALG_OP_ID_DES:
|
|
printf("(ALG_OP_ID_DES) ");
|
|
switch(aai)
|
|
{
|
|
case ALG_OP_AAI_DES_CBC: printf("(ALG_OP_AAI_DES_CBC)"); break;
|
|
case ALG_OP_AAI_DES_ECB: printf("(ALG_OP_AAI_DES_ECB)"); break;
|
|
default: printf("(Undecoded AAI)"); break;
|
|
}
|
|
break;
|
|
case ALG_OP_ID_3DES:
|
|
printf("(ALG_OP_ID_3DES) ");
|
|
switch(aai)
|
|
{
|
|
case ALG_OP_AAI_DES_CBC: printf("(ALG_OP_AAI_DES_CBC)"); break;
|
|
case ALG_OP_AAI_DES_ECB: printf("(ALG_OP_AAI_DES_ECB)"); break;
|
|
default: printf("(Undecoded AAI)"); break;
|
|
}
|
|
break;
|
|
case ALG_OP_ID_AES:
|
|
printf("(ALG_OP_ID_AES) ");
|
|
switch(aai)
|
|
{
|
|
case ALG_OP_AAI_AES_CBC: printf("(ALG_OP_AAI_AES_CBC)"); break;
|
|
case ALG_OP_AAI_AES_ECB: printf("(ALG_OP_AAI_AES_ECB)"); break;
|
|
case ALG_OP_AAI_AES_CCM: printf("(ALG_OP_AAI_AES_CCM)"); break;
|
|
default: printf("(Undecoded AAI)"); break;
|
|
}
|
|
break;
|
|
case ALG_OP_ID_ARC4:
|
|
printf("(ALG_OP_ID_ARC4) ");
|
|
break;
|
|
default:
|
|
printf("(undecoded ALG_OP_TYPE_CLASS_1)");
|
|
}
|
|
/* Encrypt/decrypt */
|
|
switch (buffer[i] & ALG_OP_DIR_MASK)
|
|
{
|
|
case ALG_OP_DIR_ENC: printf("(ALG_OP_DIR_ENC)"); break;
|
|
case ALG_OP_DIR_DEC: printf("(ALG_OP_DIR_DEC)"); break;
|
|
}
|
|
/* Algorithm State */
|
|
switch(buffer[i] & ALG_OP_AS_MASK)
|
|
{
|
|
case ALG_OP_AS_INIT: printf("(ALG_OP_AS_INIT)"); break;
|
|
case ALG_OP_AS_UPDATE: printf("(ALG_OP_AS_UPDATE)"); break;
|
|
case ALG_OP_AS_FINALIZE: printf("(ALG_OP_AS_FINALIZE)"); break;
|
|
case ALG_OP_AS_INITFINAL: printf("(ALG_OP_AS_INITFINAL)"); break;
|
|
default: break;
|
|
}
|
|
/* Check ICV */
|
|
if(buffer[i] & ALG_OP_ICV)
|
|
printf("(ALG_OP_ICV)");
|
|
break;
|
|
case ALG_OP_TYPE_CLASS_2:
|
|
switch(opId)
|
|
{
|
|
case ALG_OP_ID_MD5:
|
|
case ALG_OP_ID_SHA1:
|
|
if(ctype == ALG_OP_ID_MD5) printf("(ALG_OP_ID_MD5)");
|
|
if(ctype == ALG_OP_ID_SHA1) printf("(ALG_OP_ID_SHA1)");
|
|
switch(aai)
|
|
{
|
|
case ALG_OP_AAI_MDS_SHA_HMAC: printf("(ALG_OP_AAI_MDS_SHA_HMAC)"); break;
|
|
case ALG_OP_AAI_MDS_SHA_SMAC: printf("(ALG_OP_AAI_MDS_SHA_SMAC)"); break;
|
|
case ALG_OP_AAI_MDS_SHA_HMAC_PRECOMP: printf("(ALG_OP_AAI_MDS_SHA_HMAC_PRECOMP)"); break;
|
|
default: printf("(Undecoded AAI)"); break;
|
|
}
|
|
if(buffer[i] & ALG_OP_ICV) printf("(ALG_OP_ICV)");
|
|
break;
|
|
case ALG_OP_ID_CRC:
|
|
printf("(ALG_OP_ID_CRC) ");
|
|
switch(aai)
|
|
{
|
|
case ALG_OP_AAI_CRC_IEEE_802: printf("(ALG_OP_AAI_CRC_IEEE_802) "); break;
|
|
case ALG_OP_AAI_CRC_IETF_3385: printf("(ALG_OP_AAI_CRC_IETF_3385) "); break;
|
|
case ALG_OP_AAI_CRC_CUST_POLY: printf("(ALG_OP_AAI_CRC_CUST_POLY) "); break;
|
|
case ALG_OP_AAI_CRC_DIS_IEEE_802: printf("(ALG_OP_AAI_CRC_DIS_IEEE_802) "); break;
|
|
case ALG_OP_AAI_CRC_DIS_IETF_3385: printf("(ALG_OP_AAI_CRC_DIS_IETF_3385) "); break;
|
|
case ALG_OP_AAI_CRC_DIS_CUST_POLY: printf("(ALG_OP_AAI_CRC_DIS_CUST_POLY) "); break;
|
|
case ALG_OP_AAI_CRC_DOS_IETF_3385: printf("(ALG_OP_AAI_CRC_DOS_IETF_3385) "); break;
|
|
case ALG_OP_AAI_CRC_DOS_CUST_POLY: printf("(ALG_OP_AAI_CRC_DOS_CUST_POLY) "); break;
|
|
case ALG_OP_AAI_CRC_DOS_IEEE_802: printf("(ALG_OP_AAI_CRC_DOS_IEEE_802) "); break;
|
|
case ALG_OP_AAI_CRC_DOC_IEEE_802: printf("(ALG_OP_AAI_CRC_DOC_IEEE_802) "); break;
|
|
case ALG_OP_AAI_CRC_DOC_IETF_3385: printf("(ALG_OP_AAI_CRC_DOC_IETF_3385) "); break;
|
|
case ALG_OP_AAI_CRC_DOC_CUST_POLY: printf("(ALG_OP_AAI_CRC_DOC_CUST_POLY) "); break;
|
|
case ALG_OP_AAI_CRC_IVZ_IEEE_802: printf("(ALG_OP_AAI_CRC_IVZ_IEEE_802) "); break;
|
|
case ALG_OP_AAI_CRC_IVZ_IETF_3385: printf("(ALG_OP_AAI_CRC_IVZ_IETF_3385) "); break;
|
|
case ALG_OP_AAI_CRC_IVZ_CUST_POLY: printf("(ALG_OP_AAI_CRC_IVZ_CUST_POLY) "); break;
|
|
default:
|
|
printf("(undecoded AAI) "); break;
|
|
}
|
|
break;
|
|
default: printf("(undecoded ALG_OP_TYPE_CLASS_2)"); break;
|
|
}
|
|
break;
|
|
default:
|
|
/* Ok, not class1, class2 or pkha operation */
|
|
/* Check if protocol operation. (Is decoded a bit differently) */
|
|
switch(buffer[i] & PCL_OP_TYPE_ID_MASK)
|
|
{
|
|
case PCL_OP_TYPE_ENCAP_ID_IPSEC:
|
|
case PCL_OP_TYPE_DECAP_ID_IPSEC:
|
|
/* Do switch again for what isn't common between the two */
|
|
switch(buffer[i] & PCL_OP_TYPE_ID_MASK)
|
|
{
|
|
case PCL_OP_TYPE_ENCAP_ID_IPSEC:
|
|
pdbType = PCL_OP_TYPE_ENCAP_ID_IPSEC;
|
|
printf("(PCL_OP_TYPE_ENCAP_ID_IPSEC)");
|
|
break;
|
|
case PCL_OP_TYPE_DECAP_ID_IPSEC:
|
|
pdbType = PCL_OP_TYPE_DECAP_ID_IPSEC;
|
|
printf("(PCL_OP_TYPE_DECAP_ID_IPSEC)");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
/* Common for both PCL_OP_TYPE_DECAP_ID_IPSEC and PCL_OP_TYPE_ENCAP_ID_IPSEC */
|
|
switch(buffer[i] & 0xff00) /* PCL_OP_INFO_MASK is for IPsec really [cryptoAlg,AuthAlg] */
|
|
{
|
|
case PCL_OP_INFO_IPSEC_DES: printf("(PCL_OP_INFO_IPSEC_DES)"); break;
|
|
case PCL_OP_INFO_IPSEC_3DES: printf("(PCL_OP_INFO_IPSEC_3DES)"); break;
|
|
case PCL_OP_INFO_IPSEC_NULL_ENC: printf("(PCL_OP_INFO_IPSEC_NULL_ENC)"); break;
|
|
case PCL_OP_INFO_IPSEC_AES_CBC: printf("(PCL_OP_INFO_IPSEC_AES_CBC)"); break;
|
|
case PCL_OP_INFO_IPSEC_AES_CTR: printf("(PCL_OP_INFO_IPSEC_AES_CTR)"); break;
|
|
default: printf("(Undecoded PCL_OP_INFO crypto alg)"); break;
|
|
}
|
|
switch(buffer[i] & 0xff) /* PCL_OP_INFO_MASK is for IPsec really [cryptoAlg,AuthAlg] */
|
|
{
|
|
case PCL_OP_INFO_IPSEC_HMAC_MD5_96: printf("(PCL_OP_INFO_IPSEC_HMAC_MD5_96)"); break;
|
|
case PCL_OP_INFO_IPSEC_HMAC_SHA1_96: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA1_96)"); break;
|
|
case PCL_OP_INFO_IPSEC_AES_XCBC_MAC_96: printf("(PCL_OP_INFO_IPSEC_AES_XCBC_MAC_96)"); break;
|
|
case PCL_OP_INFO_IPSEC_HMAC_MD5_128: printf("(PCL_OP_INFO_IPSEC_HMAC_MD5_128)"); break;
|
|
case PCL_OP_INFO_IPSEC_HMAC_SHA1_160: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA1_160)"); break;
|
|
case PCL_OP_INFO_IPSEC_AES_CMAC_96: printf("(PCL_OP_INFO_IPSEC_AES_CMAC_96)"); break;
|
|
case PCL_OP_INFO_IPSEC_HMAC_SHA2_256_128: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA2_256_128)"); break;
|
|
case PCL_OP_INFO_IPSEC_HMAC_SHA2_384_192: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA2_384_192)"); break;
|
|
case PCL_OP_INFO_IPSEC_HMAC_SHA2_512_256: printf("(PCL_OP_INFO_IPSEC_HMAC_SHA2_512_256)"); break;
|
|
default: printf("(Undecoded PCL_OP_INFO auth alg)"); break;
|
|
}
|
|
break;
|
|
default:
|
|
printf("(Undecoded PCL_OP_TYPE)");
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case CMD_MATH:
|
|
printf("CMD_MATH: ");
|
|
switch(buffer[i] & MATH_FUNC_MASK)
|
|
{
|
|
case MATH_FUNC_ADD: printf("(MATH_FUNC_ADD)"); break;
|
|
case MATH_FUNC_ADD_W_CARRY: printf("(MATH_FUNC_ADD_W_CARRY)"); break;
|
|
case MATH_FUNC_SUB: printf("(MATH_FUNC_SUB)"); break;
|
|
case MATH_FUNC_SUB_W_BORROW: printf("(MATH_FUNC_SUB_W_BORROW)"); break;
|
|
case MATH_FUNC_OR: printf("(MATH_FUNC_OR)"); break;
|
|
case MATH_FUNC_AND: printf("(MATH_FUNC_AND)"); break;
|
|
case MATH_FUNC_XOR: printf("(MATH_FUNC_XOR)"); break;
|
|
case MATH_FUNC_SHIFT_L: printf("(MATH_FUNC_SHIFT_L)"); break;
|
|
case MATH_FUNC_SHIFT_R: printf("(MATH_FUNC_SHIFT_R)"); break;
|
|
case MATH_FUNC_SHLD: printf("(MATH_FUNC_SHLD)"); break;
|
|
case MATH_FUNC_ZBYT: printf("(MATH_FUNC_ZBYT)"); break;
|
|
}
|
|
switch(buffer[i] & MATH_SRC0_MASK)
|
|
{
|
|
case MATH_SRC0_REG0: printf("(MATH_SRC0_REG0)"); break;
|
|
case MATH_SRC0_REG1: printf("(MATH_SRC0_REG1)"); break;
|
|
case MATH_SRC0_REG2: printf("(MATH_SRC0_REG2)"); break;
|
|
case MATH_SRC0_REG3: printf("(MATH_SRC0_REG3)"); break;
|
|
case MATH_SRC0_IMM:
|
|
printf("(MATH_SRC0_IMM)");
|
|
next_data_is_immediate = 1;
|
|
next_data_size = next_data_is_immediate * sizeof(uint32_t);
|
|
break;
|
|
case MATH_SRC0_SIL: printf("(MATH_SRC0_SIL)"); break;
|
|
case MATH_SRC0_SOL: printf("(MATH_SRC0_SOL)"); break;
|
|
case MATH_SRC0_VSIL: printf("(MATH_SRC0_VSIL)"); break;
|
|
case MATH_SRC0_VSOL: printf("(MATH_SRC0_VSOL)"); break;
|
|
case MATH_SRC0_ZERO: printf("(MATH_SRC0_ZERO)"); break;
|
|
case MATH_SRC0_MASK: printf("(MATH_SRC0_MASK)"); break;
|
|
}
|
|
switch(buffer[i] & MATH_SRC1_MASK)
|
|
{
|
|
case MATH_SRC1_REG0: printf("(MATH_SRC1_REG0)"); break;
|
|
case MATH_SRC1_REG1: printf("(MATH_SRC1_REG1)"); break;
|
|
case MATH_SRC1_REG2: printf("(MATH_SRC1_REG2)"); break;
|
|
case MATH_SRC1_REG3: printf("(MATH_SRC1_REG3)"); break;
|
|
case MATH_SRC1_IMM:
|
|
printf("(MATH_SRC1_IMM)");
|
|
next_data_is_immediate = 1;
|
|
next_data_size = next_data_is_immediate * sizeof(uint32_t);
|
|
break;
|
|
case MATH_SRC1_IFIFO: printf("(MATH_SRC1_IFIFO)"); break;
|
|
case MATH_SRC1_OFIFO: printf("(MATH_SRC1_OFIFO)"); break;
|
|
case MATH_SRC1_ONE: printf("(MATH_SRC1_ONE)"); break;
|
|
case MATH_SRC1_JOB: printf("(MATH_SRC1_JOB)"); break;
|
|
case MATH_SRC1_ZERO: printf("(MATH_SRC1_ZERO)"); break;
|
|
}
|
|
switch(buffer[i] & MATH_DST_MASK)
|
|
{
|
|
case MATH_DST_REG0: printf("(MATH_DST_REG0)"); break;
|
|
case MATH_DST_REG1: printf("(MATH_DST_REG1)"); break;
|
|
case MATH_DST_REG2: printf("(MATH_DST_REG2)"); break;
|
|
case MATH_DST_REG3: printf("(MATH_DST_REG3)"); break;
|
|
case MATH_DST_IMM: printf("(MATH_DST_IMM)"); break;
|
|
case MATH_DST_SIL: printf("(MATH_DST_SIL)"); break;
|
|
case MATH_DST_SOL: printf("(MATH_DST_SOL)"); break;
|
|
case MATH_DST_VSIL: printf("(MATH_DST_VSIL)"); break;
|
|
case MATH_DST_VSOL: printf("(MATH_DST_VSOL)"); break;
|
|
case MATH_DST_NONE: printf("(MATH_DST_NONE)"); break;
|
|
}
|
|
switch(buffer[i] & MATH_LEN_MASK)
|
|
{
|
|
case MATH_LEN_1_BYTE: printf("(MATH_LEN_1_BYTE)"); break;
|
|
case MATH_LEN_2_BYTE: printf("(MATH_LEN_2_BYTE)"); break;
|
|
case MATH_LEN_4_BYTE: printf("(MATH_LEN_4_BYTE)"); break;
|
|
case MATH_LEN_8_BYTE: printf("(MATH_LEN_8_BYTE)"); break;
|
|
}
|
|
if(buffer[i] & MATH_IFB(1)) printf("(MATH_IFB)");
|
|
if(buffer[i] & MATH_NFU) printf("(MATH_NFU)");
|
|
if(buffer[i] & MATH_STL) printf("(MATH_STL)");
|
|
break;
|
|
case CMD_MOVE:
|
|
#define MOVE_GET_OFFSET(n) (((n)&0xFF00) >> 8)
|
|
printf("CMD_MOVE: ");
|
|
if(buffer[i] & MOVE_WC)
|
|
{
|
|
printf("(MOVE_WC)");
|
|
}
|
|
switch(buffer[i] & MOVE_AUX_SRC_DST_MASK)
|
|
{
|
|
case MOVE_AUX_FLSH_C2A_SRC_IFIFO2_DST_OFIFO:
|
|
printf("(MOVE_AUX_FLSH_C2A_SRC_IFIFO2_DST_OFIFO)");
|
|
break;
|
|
default:
|
|
printf("(Undecoded src & dst)");
|
|
break;
|
|
}
|
|
printf("(offset = 0x%x)", MOVE_GET_OFFSET(buffer[i]));
|
|
printf("(length = 0x%x)", MOVE_LENGTH(buffer[i]));
|
|
break;
|
|
case CMD_FIFO_STORE + 1:
|
|
printf("SEQ ");
|
|
case CMD_FIFO_STORE:
|
|
printf("CMD_FIFO_STORE: ");
|
|
if (0 != (buffer[i] & FIFO_STORE_VLF))
|
|
printf("(SGF)");
|
|
if (0 != (buffer[i] & FIFO_STORE_CONT))
|
|
printf("(CONT)");
|
|
if (0 != (buffer[i] & FIFO_STORE_EXT))
|
|
printf("(EXT)");
|
|
switch(buffer[i] & FIFO_STORE_CLASS_TYPE_MASK)
|
|
{
|
|
case FIFO_STORE_CLASS_UNUSED_TYPE_MSG: printf("(FIFO_STORE_CLASS_UNUSED_TYPE_MSG)"); break;
|
|
case FIFO_STORE_CLASS_UNUSED_TYPE_SKIP: printf("(FIFO_STORE_CLASS_UNUSED_TYPE_SKIP)"); break;
|
|
case FIFO_STORE_CLASS_1_TYPE_PKHA_B: printf("(FIFO_STORE_CLASS_1_TYPE_PKHA_B)"); break;
|
|
case FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_CCM_JKEK: printf("(FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_CCM_JKEK)"); break;
|
|
case FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_CCM_TKEK: printf("(FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_CCM_TKEK)"); break;
|
|
case FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_ECB_JKEK: printf("(FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_ECB_JKEK)"); break;
|
|
case FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_JKEK: printf("(FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_JKEK)"); break;
|
|
case FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_TKEK: printf("(FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_TKEK)"); break;
|
|
case FIFO_STORE_CLASS_1_TYPE_OFIFO_ECB_JKEK: printf("(FIFO_STORE_CLASS_1_TYPE_OFIFO_ECB_JKEK)"); break;
|
|
case FIFO_STORE_CLASS_2_TYPE_OFIFO_ECB_JKEK: printf("(FIFO_STORE_CLASS_2_TYPE_OFIFO_ECB_JKEK)"); break;
|
|
case FIFO_STORE_CLASS_1_TYPE_OFIFO_ECB_TKEK: printf("(FIFO_STORE_CLASS_1_TYPE_OFIFO_ECB_TKEK)"); break;
|
|
case FIFO_STORE_CLASS_2_TYPE_OFIFO_ECB_TKEK: printf("(FIFO_STORE_CLASS_2_TYPE_OFIFO_ECB_TKEK)"); break;
|
|
|
|
default: printf("(undecoded Fifo Store src 0x%x) ", buffer[i] & FIFO_STORE_CLASS_TYPE_MASK); break;
|
|
}
|
|
if(ctype == CMD_FIFO_STORE)
|
|
{
|
|
if (buffer[i] & FIFO_STORE_SGT)
|
|
{
|
|
printf("(FIFO_STORE_SGT)");
|
|
next_data_is_sgt = ptrSize; /* Next word contains pointer to Scatter gather table */
|
|
}
|
|
else
|
|
{
|
|
next_data_is_pointer=ptrSize;
|
|
next_data_size=FIFO_STORE_LENGTH(buffer[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* SEQ CMD_FIFO_STORE */
|
|
printf("(Output sequence data)");
|
|
if (buffer[i] & FIFO_STORE_VLF)
|
|
printf("(FIFO_STORE_VLF)");
|
|
}
|
|
printf("(length = 0x%x)", FIFO_STORE_LENGTH(buffer[i]));
|
|
break;
|
|
case CMD_FIFO_LOAD + 1:
|
|
/* Sequence FIFO LOAD*/
|
|
printf("SEQ ");
|
|
case CMD_FIFO_LOAD:
|
|
printf("CMD_FIFO_LOAD: ");
|
|
switch(buffer[i] & FIFO_LOAD_CLASS_TYPE_MASK)
|
|
{
|
|
case FIFO_LOAD_CLASS_SKIP_TYPE_UNUSED: printf("(FIFO_LOAD_CLASS_SKIP_TYPE_UNUSED)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_AAD_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_AAD_F1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_MSG: printf("(FIFO_LOAD_CLASS_1_TYPE_MSG)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_MSG_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_MSG_F1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_MSG_L1: printf("(FIFO_LOAD_CLASS_1_TYPE_MSG_L1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_MSG_L1_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_MSG_L1_F1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_IV: printf("(FIFO_LOAD_CLASS_1_TYPE_IV)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_IV_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_IV_F1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_IV_L1: printf("(FIFO_LOAD_CLASS_1_TYPE_IV_L1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_IV_L1_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_IV_L1_F1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_PKHA_A: printf("(FIFO_LOAD_CLASS_1_TYPE_PKHA_A)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_PKHA_B: printf("(FIFO_LOAD_CLASS_1_TYPE_PKHA_B)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_PKHA_N: printf("(FIFO_LOAD_CLASS_1_TYPE_PKHA_N)"); break;
|
|
case FIFO_LOAD_CLASS_2_TYPE_MSG: printf("(FIFO_LOAD_CLASS_2_TYPE_MSG)"); break;
|
|
case FIFO_LOAD_CLASS_2_TYPE_MSG_L2: printf("(FIFO_LOAD_CLASS_2_TYPE_MSG_L2)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_ICV: printf("(FIFO_LOAD_CLASS_1_TYPE_ICV)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_ICV_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_ICV_F1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_ICV_L1: printf("(FIFO_LOAD_CLASS_1_TYPE_ICV_L1)"); break;
|
|
case FIFO_LOAD_CLASS_1_TYPE_ICV_L1_F1: printf("(FIFO_LOAD_CLASS_1_TYPE_ICV_L1_F1)"); break;
|
|
case FIFO_LOAD_CLASS_2_TYPE_ICV: printf("(FIFO_LOAD_CLASS_2_TYPE_ICV)"); break;
|
|
case FIFO_LOAD_CLASS_2_TYPE_ICV_L2: printf("(FIFO_LOAD_CLASS_2_TYPE_ICV_L2)"); break;
|
|
default: printf("(undecoded load type)"); break;
|
|
}
|
|
if (!(buffer[i] & FIFO_LOAD_IMM) && !(buffer[i] & FIFO_LOAD_SGT) && (ctype == CMD_FIFO_LOAD))
|
|
{
|
|
next_data_is_pointer = ptrSize;
|
|
next_data_size = FIFO_LOAD_LENGTH(buffer[i]);
|
|
}
|
|
else if (buffer[i] & FIFO_LOAD_IMM)
|
|
{
|
|
printf("(IMM data)");
|
|
if(FIFO_LOAD_LENGTH(buffer[i]) > 0)
|
|
{
|
|
next_data_is_immediate = 2;
|
|
next_data_size = next_data_is_immediate * sizeof(uint32_t);
|
|
}
|
|
else
|
|
{
|
|
printf("(0 length data)");
|
|
}
|
|
}
|
|
else if ((buffer[i] & FIFO_LOAD_SGT) && (ctype == CMD_FIFO_LOAD))
|
|
{
|
|
printf("(FIFO_LOAD_SGT)");
|
|
next_data_is_sgt = ptrSize; /* Next word contains pointer to Scatter gather table */
|
|
}
|
|
else if (buffer[i] & FIFO_LOAD_VLF && (ctype == CMD_FIFO_LOAD + 1))
|
|
{
|
|
printf("(VLF)");
|
|
}
|
|
printf("(length = 0x%x)", FIFO_LOAD_LENGTH(buffer[i]));
|
|
break;
|
|
case CMD_STORE:
|
|
next_data_is_pointer=ptrSize;
|
|
next_data_size = STORE_LENGTH(buffer[i]);
|
|
case CMD_STORE + 1: /* SEQ STORE */
|
|
if(ctype == CMD_STORE)
|
|
{
|
|
printf("CMD_STORE: ");
|
|
}
|
|
else
|
|
{
|
|
printf("SEQ CMD_STORE: ");
|
|
}
|
|
switch(buffer[i] & STORE_CLASS_SRC_MASK)
|
|
{
|
|
case STORE_CLASS_1_SRC_CTX: printf("(STORE_CLASS_1_SRC_CTX)"); break;
|
|
case STORE_CLASS_2_SRC_CTX: printf("(STORE_CLASS_2_SRC_CTX)"); break;
|
|
default: printf("(undecoded src)"); break;
|
|
}
|
|
printf("(LENGTH=0x%x)", STORE_LENGTH(buffer[i]));
|
|
if ((buffer[i] & STORE_OFFSET(0xff)) != 0)
|
|
{
|
|
printf("(OFFSET=0x%x)", (buffer[i] & STORE_OFFSET(0xff)) >> 8);
|
|
}
|
|
if(buffer[i] & STORE_VLF) printf("(STORE_VLF)");
|
|
//if(buffer[i] & STORE_SGT) printf("(STORE_SGT)"); /*TODO*/
|
|
if(buffer[i] & STORE_IMM) printf("(STORE_IMM)");
|
|
break;
|
|
case CMD_LOAD + 1:
|
|
/* Sequential load command */
|
|
printf("SEQ ");
|
|
case CMD_LOAD:
|
|
printf("CMD_LOAD: ");
|
|
switch(buffer[i] & LOAD_CLASS_DST_MASK)
|
|
{
|
|
case DCTRL_LOAD_CLASS_DECO_IMM_DST_REG & ~LOAD_IMM:
|
|
if(buffer[i] & LOAD_IMM)
|
|
{
|
|
printf("(DCTRL_LOAD_CLASS_DECO_IMM_DST_REG)");
|
|
switch(buffer[i] & DCTRL_LOAD_AUTO_IFIFO_MASK)
|
|
{
|
|
case DCTRL_LOAD_AUTO_IFIFO_DISABLED: printf("(DCTRL_LOAD_AUTO_IFIFO_DISABLED)"); break;
|
|
case DCTRL_LOAD_AUTO_IFIFO_ENABLED: printf("(DCTRL_LOAD_AUTO_IFIFO_ENABLED)"); break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LOAD_CLASS_1_DST_IVSZ: printf("(LOAD_CLASS_1_DST_IVSZ)"); break;
|
|
case LOAD_CLASS_1_DST_CTX: printf("(LOAD_CLASS_1_DST_CTX)"); break;
|
|
case LOAD_CLASS_2_DST_CTX: printf("(LOAD_CLASS_2_DST_CTX)"); break;
|
|
default: printf("(undecoded load dst)"); break;
|
|
}
|
|
printf("(LENGTH=0x%x)", LOAD_LENGTH(buffer[i]));
|
|
if ((buffer[i] & LOAD_OFFSET(0xff)) != 0)
|
|
{
|
|
printf("(OFFSET=0x%x)", (buffer[i] & LOAD_OFFSET(0xff)) >> 8);
|
|
}
|
|
if(ctype == CMD_LOAD)
|
|
{
|
|
if (!(buffer[i] & LOAD_IMM))
|
|
{
|
|
next_data_is_pointer = ptrSize;
|
|
next_data_size = LOAD_LENGTH(buffer[i]);
|
|
}
|
|
else if((buffer[i] & LOAD_CLASS_DST_MASK) != (DCTRL_LOAD_CLASS_DECO_IMM_DST_REG & ~LOAD_IMM))
|
|
{
|
|
printf("(IMM data)");
|
|
next_data_is_immediate = 1; /*TODO fix size. This is only for "word length" commands*/
|
|
}
|
|
}
|
|
if(buffer[i] & LOAD_VLF) printf("(LOAD_VLF)");
|
|
if(buffer[i] & LOAD_SGT) printf("(LOAD_SGT)");
|
|
if(buffer[i] & LOAD_IMM) printf("(LOAD_IMM)");
|
|
break;
|
|
case CMD_JUMP:
|
|
printf("CMD_JUMP: ");
|
|
switch(buffer[i] & JUMP_CLASS_MASK)
|
|
{
|
|
case JUMP_CLASS_BOTH: printf("(JUMP_CLASS_BOTH)"); break;
|
|
default: printf("(Undecoded jump class)"); break;
|
|
}
|
|
switch(buffer[i] & JUMP_TYPE_MASK)
|
|
{
|
|
case JUMP_TYPE_LOCAL: printf("(JUMP_TYPE_LOCAL)"); break;
|
|
case JUMP_TYPE_NON_LOCAL: printf("(JUMP_TYPE_NON_LOCAL)");
|
|
next_data_is_immediate = 1; /* Pointer to another descriptor word */
|
|
next_data_size = ptrSize;
|
|
break;
|
|
case JUMP_TYPE_HALT_TEST_STATUS: printf("(JUMP_TYPE_HALT_TEST_STATUS)"); break;
|
|
case JUMP_TYPE_HALT_USER_STATUS: printf("(JUMP_TYPE_HALT_USER_STATUS)"); break;
|
|
default: printf("(Undecoded jump class)"); break;
|
|
}
|
|
switch(buffer[i] & JUMP_TEST_MASK)
|
|
{
|
|
case JUMP_TEST_ANY_MISMATCH: printf("(JUMP_TEST_ANY_MISMATCH)"); break;
|
|
case JUMP_TEST_ANY_MATCH: printf("(JUMP_TEST_ANY_MATCH)"); break;
|
|
case JUMP_TEST_ALL_MISMATCH: printf("(JUMP_TEST_ALL_MISMATCH)"); break;
|
|
case JUMP_TEST_ALL_MATCH: printf("(JUMP_TEST_ALL_MATCH)"); break;
|
|
default: printf("undecoded JUMP_TEST"); break;
|
|
}
|
|
switch(buffer[i] & (JUMP_COND_MASK | JUMP_SL_MASK))
|
|
{
|
|
/* Dual meanings depending on other as well */
|
|
case JUMP_SL_0 | JUMP_COND_SL_0_MATH_NV: printf("(JUMP_COND_SL_0_MATH_NV)"); break;
|
|
case JUMP_SL_1 | JUMP_COND_SL_1_NCP: printf("(JUMP_COND_SL_1_NCP)"); break;
|
|
case JUMP_SL_0 | JUMP_COND_SL_0_MATH_C: printf("(JUMP_COND_SL_0_MATH_C)"); break;
|
|
case JUMP_SL_1 | JUMP_COND_SL_1_NOP: printf("(JUMP_COND_SL_1_NOP)"); break;
|
|
case JUMP_SL_0 | JUMP_COND_SL_0_MATH_Z: printf("(JUMP_COND_SL_0_MATH_Z)"); break;
|
|
case JUMP_SL_1 | JUMP_COND_SL_1_NIFP: printf("(JUMP_COND_SL_1_NIFP)"); break;
|
|
case JUMP_SL_0 | JUMP_COND_SL_0_MATH_N: printf("(JUMP_COND_SL_0_MATH_N)"); break;
|
|
case JUMP_SL_1 | JUMP_COND_SL_1_NIP: printf("(JUMP_COND_SL_1_NIP)"); break;
|
|
case JUMP_SL_0 | JUMP_COND_SL_0_NOT_USED: printf("(JUMP_COND_SL_0_NOT_USED)"); break;
|
|
case JUMP_SL_1 | JUMP_COND_SL_1_CALM: printf("(JUMP_COND_SL_1_CALM)"); break;
|
|
case JUMP_SL_0 | JUMP_COND_SL_0_PKHA_IS_PRIME: printf("(JUMP_COND_SL_0_PKHA_IS_PRIME)"); break;
|
|
case JUMP_SL_1 | JUMP_COND_SL_1_SELF: printf("(JUMP_COND_SL_1_SELF)"); break;
|
|
case JUMP_SL_0 | JUMP_COND_SL_0_PKHA_GCD_ONE: printf("(JUMP_COND_SL_0_PKHA_GCD_ONE)"); break;
|
|
case JUMP_SL_1 | JUMP_COND_SL_1_SHRD: printf("(JUMP_COND_SL_1_SHRD)"); break;
|
|
case JUMP_SL_0 | JUMP_COND_SL_0_PKHA_IS_ZERO: printf("(JUMP_COND_SL_0_PKHA_IS_ZERO)"); break;
|
|
case JUMP_SL_1 | JUMP_COND_SL_1_JQP: printf("(JUMP_COND_SL_1_JQP)"); break;
|
|
default: printf("(Undecoded JUMP_COND)");
|
|
}
|
|
printf("(localOffset=0x%x)", JUMP_LOCAL_OFFSET(buffer[i]));
|
|
break;
|
|
default:
|
|
printf("undecoded ctype");
|
|
break;
|
|
}
|
|
printf("\n");
|
|
}
|
|
else /* immediate data, data pointer, SGT or pdb*/
|
|
{
|
|
if (next_data_is_pointer != 0)
|
|
{
|
|
next_data_is_pointer--;
|
|
printf("(data pointer word %d)\n", next_data_is_pointer);
|
|
/* print pointer data if any */
|
|
if((next_data_is_pointer == 0) && (next_data_size > 0))
|
|
{
|
|
printBufIx = sprintf(printBuf," ----> 0x");
|
|
for(j=0;j<next_data_size;j++)
|
|
{
|
|
if((j & 0x3) == 0)
|
|
printBufIx += sprintf(&printBuf[printBufIx]," ");
|
|
printBufIx += sprintf(&printBuf[printBufIx],"%02x", ((uint8_t *)XX_PhysToVirt((physAddress_t *)(buffer[i])))[j] ); /*TODO: do according to ptr size */
|
|
if((j >= (PRINT_DATA_LIMIT-1)) && (((next_data_size - 1) - j) > 4))
|
|
{
|
|
printBufIx += sprintf(&printBuf[printBufIx]," ... <data output limited to %d bytes> ... ", PRINT_DATA_LIMIT);
|
|
j = next_data_size - 4 - 1;
|
|
}
|
|
|
|
}
|
|
printBufIx += sprintf(&printBuf[printBufIx],"\0");
|
|
printf("%s\n",printBuf);
|
|
next_data_size = 0;
|
|
}
|
|
}
|
|
else if(next_data_is_immediate != 0) /* immediate data */
|
|
{
|
|
next_data_is_immediate--;
|
|
printf("(immediate data word %d)\n", next_data_is_immediate);
|
|
}
|
|
else if(next_data_is_sgt != 0) /* Scatter gather table */
|
|
{
|
|
next_data_is_sgt--;
|
|
printf("(SGT pointer word %d)\n", next_data_is_sgt);
|
|
if(next_data_is_sgt == 0)
|
|
{
|
|
int sgt_entry_is_last = 0;
|
|
t_SGTEntry *sgt_entry = (t_SGTEntry *)XX_PhysToVirt((physAddress_t *)(buffer[i])); /*TODO: do according to ptr size */;
|
|
/* Print Scatter gather table */
|
|
printf(" ----> Scatter Gather Table\n");
|
|
while(sgt_entry_is_last == 0)
|
|
{
|
|
printf("\t0x");
|
|
for(j=0; j < (sizeof(t_SGTEntry)/sizeof(uint32_t)); j++) /*SGT size is 16 bytes */
|
|
{
|
|
printf("%08x ", ((uint32_t *)sgt_entry)[j]);
|
|
/* See if this is last entry in SGT */
|
|
if((j == 2) && (sgt_entry->final == 1))
|
|
{
|
|
sgt_entry_is_last = 1;
|
|
}
|
|
}
|
|
/* Print data */
|
|
printf(" ----> ");
|
|
for(int k=0; k < sgt_entry->length; k++)
|
|
{
|
|
if((k & 0x3) == 0)
|
|
printf(" ");
|
|
printf("%02x", ((uint8_t *)XX_PhysToVirt((physAddress_t)(sgt_entry->address + (uint16_t)sgt_entry->offset)))[k] ); /*TODO: do according to ptr size */
|
|
if((k >= (PRINT_DATA_LIMIT-1)) && (((sgt_entry->length - 1) - k) > 4))
|
|
{
|
|
printf(" ... <data output limited to %d bytes> ... ", PRINT_DATA_LIMIT);
|
|
k = sgt_entry->length - 4 - 1;
|
|
}
|
|
}
|
|
printf("\n");
|
|
sgt_entry++;
|
|
}
|
|
}
|
|
}
|
|
else /* pdb (protocol descriptor block) data */
|
|
{
|
|
next_data_is_pdb--;
|
|
printf("(pdb data word %d)\n", startIndex-next_data_is_pdb);
|
|
}
|
|
}
|
|
}
|
|
/* Now when all is decoded we know how to decode the PDB if there is one */
|
|
if(pdbType != 0)
|
|
PrintDecodePDB(&(buffer[pdbIndex]), pdbType);
|
|
}
|
|
|
|
void
|
|
PrintDecodePDB(uint32_t* buf_p, uint32_t pdbType)
|
|
{
|
|
union pdb {
|
|
t_IpsecEncapPdb *ipsecEncapPdb;
|
|
t_IpsecDecapPdb *ipsecDecapPdb;
|
|
} pdb;
|
|
|
|
printf(" Decoded PDB block: ");
|
|
|
|
switch(pdbType)
|
|
{
|
|
case PCL_OP_TYPE_ENCAP_ID_IPSEC:
|
|
printf("PCL_OP_TYPE_ENCAP_ID_IPSEC\n");
|
|
pdb.ipsecEncapPdb = (t_IpsecEncapPdb *) buf_p;
|
|
printf("\tNextHeader=0x%x\n", pdb.ipsecEncapPdb->nextHdr);
|
|
printf("\tnhOffset=0x%x\n", pdb.ipsecEncapPdb->nhOffset);
|
|
printf("\tseqNum=0x%x\n", pdb.ipsecEncapPdb->seqNum);
|
|
printf("\toptions=0x%x\n", pdb.ipsecEncapPdb->options);
|
|
printf("\t SPI=0x%x\n", pdb.ipsecEncapPdb->spi);
|
|
printf("\t DF bit copy=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_HMO_DFC) == 0 ? 0 : 1);
|
|
printf("\t Decrease TTL=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_HMO_DTTL) == 0 ? 0 : 1);
|
|
printf("\t Checksum update=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_CKSM) == 0 ? 0 : 1);
|
|
printf("\t Diffserv copy=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_DSC) == 0 ? 0 : 1);
|
|
printf("\t IV src=%s \n",(pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_IVSRC) == 0 ? "pdb" : "rng");
|
|
printf("\t ESN=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_ESN) == 0 ? 0 : 1);
|
|
printf("\t IP Header src=%s\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_SRC) == 0 ? "frame" : "pdb");
|
|
printf("\t Prepend IPHdr=%d\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_INC) == 0 ? 0 : 1);
|
|
printf("\t IP version=%s\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_IPV6) == 0 ? "v4" : "v6");
|
|
printf("\t Mode=%s\n", (pdb.ipsecEncapPdb->options & IPSEC_ENCAP_OPTION_TUNNEL) == 0 ? "transport" : "tunnel");
|
|
break;
|
|
case PCL_OP_TYPE_DECAP_ID_IPSEC:
|
|
printf("PCL_OP_TYPE_DECAP_ID_IPSEC\n");
|
|
pdb.ipsecDecapPdb = (t_IpsecDecapPdb *) buf_p;
|
|
printf("\tipHdrLen=%d\n", pdb.ipsecDecapPdb->ipHdrLen);
|
|
printf("\tnhOffset=0x%x\n", pdb.ipsecDecapPdb->nhOffset);
|
|
printf("\tseqNum=0x%x\n", pdb.ipsecDecapPdb->seqNum);
|
|
printf("\toptions=0x%x\n", pdb.ipsecDecapPdb->options);
|
|
printf("\t Decrease TTL=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_HMO_DTTL) == 0 ? 0 : 1);
|
|
printf("\t Diffserv copy=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_HMO_DSC) == 0 ? 0 : 1);
|
|
printf("\t ARS64=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_ARS64) == 0 ? 0 : 1);
|
|
printf("\t ARS32=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_ARS32) == 0 ? 0 : 1);
|
|
printf("\t Checksum verification=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_CKSM) == 0 ? 0 : 1);
|
|
printf("\t ESN=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_ESN) == 0 ? 0 : 1);
|
|
printf("\t Outframe format (FMT)=%d\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_FMT) == 0 ? 0 : 1);
|
|
printf("\t IP version=%s\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_IPV6) == 0 ? "v4" : "v6");
|
|
printf("\t Mode=%s\n", (pdb.ipsecDecapPdb->options & IPSEC_DECAP_OPTION_TUNNEL) == 0 ? "transport" : "tunnel");
|
|
break;
|
|
default:
|
|
printf("(undecoded PDB type)\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
SEC_DCL_DebugPrintDescriptor(t_Desc* jobDescHandle)
|
|
{
|
|
uint32_t descLen;
|
|
|
|
printf("Job descriptor @ 0x%x\n", (uint32_t) jobDescHandle);
|
|
printf(" p_Prefix = 0x%x\n", (uint32_t) jobDescHandle->p_Prefix);
|
|
printf(" p_Postfix = 0x%x\n", (uint32_t) jobDescHandle->p_Postfix);
|
|
printf(" p_Mem = 0x%x\n", (uint32_t) jobDescHandle->p_Mem);
|
|
printf(" p_Buffer = 0x%x\n", (uint32_t) jobDescHandle->p_Buffer);
|
|
printf(" BufSize = 0x%x\n", jobDescHandle->bufferSize);
|
|
descLen = ((uint32_t *)jobDescHandle->p_Buffer)[0] & 0x7f;
|
|
|
|
PrintDecodeDescriptor((uint32_t *)jobDescHandle->p_Buffer, NULL);
|
|
}
|
|
|
|
#ifdef SEC4_USE_QI
|
|
void
|
|
SEC_DCL_DebugPrintPreHeader(t_SecPreHeader* preHeader)
|
|
{
|
|
printf("SEC4 pre header @ 0x%x\n", preHeader);
|
|
|
|
printf("\tRSLS=%d, ", SEC_PH_GET_RSLS(preHeader));
|
|
printf("SDLEN=%d, ", SEC_PH_GET_SDLEN(preHeader));
|
|
printf("FSGT=%d, ", SEC_PH_GET_FSGT(preHeader));
|
|
printf("LONG=%d, ", SEC_PH_GET_LONG(preHeader));
|
|
printf("OFFSET=%d, ", SEC_PH_GET_OFFSET(preHeader));
|
|
printf("ABS=%d, ", SEC_PH_GET_ABS(preHeader));
|
|
printf("ADDBUF=%d, ", SEC_PH_GET_ADDBUF(preHeader));
|
|
printf("POOLID=%d, ", SEC_PH_GET_POOLID(preHeader));
|
|
printf("BUFSIZE=%d\n", SEC_PH_GET_BUFSIZE(preHeader));
|
|
|
|
}
|
|
#endif /* #ifdef SEC4_USE_QI */
|
|
|
|
#endif /* #ifdef DBG */
|