sec2_global.c

freescale ppc sec2加解密单元驱动

 */
const unsigned long TlsBlockOutboundReq[1 * NUM_TLS_BLOCK_OUTBOUND_DESC] = {
    /* DPD_TLS_BLOCK_OUTBOUND OpId 0x9100 */
    0x00000000
};

/*
 * Header constants for TLS_STREAM_INBOUND_REQ / DPD_TLS_STREAM_INBOUND_GROUP
 */
const unsigned long TlsStreamInboundReq[1 * NUM_TLS_STREAM_INBOUND_DESC] = {
    /* DPD_TLS_STREAM_INBOUND OpId 0x9200 */
    0x00000000
};

/*
 * Header constants for TLS_STREAM_OUTBOUND_REQ / DPD_TLS_STREAM_OUTBOUND_GROUP
 */
const unsigned long TlsStreamOutboundReq[1 * NUM_TLS_STREAM_OUTBOUND_DESC] = {
    /* DPD_TLS_STREAM_OUTBOUND OpId 0x9300 */
    0x00000000
};

static char NIL[] = {"NIL"};

DPD_DETAILS_ENTRY sec2_DpdDetails[] =
{


    /* DPD_RNG_GROUP */
    {
        DPD_RNG_GROUP, "DPD_RNG_GROUP",
        sizeof(RNG_REQ), sec2_RngDesc,
        offsetof(RNG_REQ,rngBytes),
        {
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"rngData",     STD_OFFSETS(RNG_REQ,rngBytes,rngBytes,rngData,rngData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },




    /* DPD_DES_CBC_GROUP */
    {
        DPD_DES_CBC_GROUP, "DPD_DES_CBC_GROUP",
        sizeof(DES_CBC_CRYPT_REQ), DesCbcReq,
        offsetof(DES_CBC_CRYPT_REQ,inBytes),
        {
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"inIvData",    STD_OFFSETS(DES_CBC_CRYPT_REQ,inIvBytes,inIvBytes,inIvData,outIvData), Read, ChkDesIvLen},
            {"keyData",     STD_OFFSETS(DES_CBC_CRYPT_REQ,keyBytes,keyBytes,keyData,keyData), Read, ChkDesKeyLen},
            {"inData",      STD_OFFSETS(DES_CBC_CRYPT_REQ,inBytes,inBytes,inData,inData), Read, ChkDesDataLen},
            {"outData",     STD_OFFSETS(DES_CBC_CRYPT_REQ,inBytes,inBytes,outData,outData), Write, NULL},
            {"outIvData",   STD_OFFSETS(DES_CBC_CRYPT_REQ,outIvBytes,outIvBytes,outIvData,outIvData), Write, ChkDesIvLen},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },




    /* DPD_DES_ECB_GROUP */
    {
        DPD_DES_ECB_GROUP, "DPD_DES_ECB_GROUP",
        sizeof(DES_CRYPT_REQ), DesReq,
        offsetof(DES_CRYPT_REQ,inBytes),
        {
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"keyData",     STD_OFFSETS(DES_CRYPT_REQ,keyBytes,keyBytes,keyData,keyData), Read, ChkDesKeyLen},
            {"inData",      STD_OFFSETS(DES_CRYPT_REQ,inBytes,inBytes,inData,inData), Read, ChkDesDataLen},
            {"outData",     STD_OFFSETS(DES_CRYPT_REQ,inBytes,inBytes,outData,outData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_RC4_LDCTX_CRYPT_ULCTX_GROUP */
    {
        DPD_RC4_LDCTX_CRYPT_ULCTX_GROUP, "DPD_RC4_LDCTX_CRYPT_ULCTX_GROUP",
        sizeof(ARC4_LOADCTX_CRYPT_REQ), sec2_Rc4LoadCtxUnloadCtxReq,
        offsetof(ARC4_LOADCTX_CRYPT_REQ,inBytes),
        {
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"inCtxData",   STD_OFFSETS(ARC4_LOADCTX_CRYPT_REQ,inCtxBytes,inCtxBytes,inCtxData,outCtxData), Read, ChkArcCtxLen},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"inData",      STD_OFFSETS(ARC4_LOADCTX_CRYPT_REQ,inBytes,inBytes,inData,inData), Read, NULL},
            {"outData",     STD_OFFSETS(ARC4_LOADCTX_CRYPT_REQ,inBytes,inBytes,outData,outData), Write, NULL},
            {"outCtxData",  STD_OFFSETS(ARC4_LOADCTX_CRYPT_REQ,outCtxBytes,outCtxBytes,outCtxData,outCtxData), Write, ChkArcCtxLen},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },




    /* DPD_RC4_LDKEY_CRYPT_ULCTX_GROUP */
    {
        DPD_RC4_LDKEY_CRYPT_ULCTX_GROUP, "DPD_RC4_LDKEY_CRYPT_ULCTX_GROUP",
        sizeof(ARC4_LOADKEY_CRYPT_UNLOADCTX_REQ), sec2_Rc4LoadKeyUnloadCtxReq,
        offsetof(ARC4_LOADKEY_CRYPT_UNLOADCTX_REQ,inBytes),
        {
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"keyData",     STD_OFFSETS(ARC4_LOADKEY_CRYPT_UNLOADCTX_REQ,keyBytes,keyBytes,keyData,keyData), Read, ChkArcKeyLen},
            {"inData",      STD_OFFSETS(ARC4_LOADKEY_CRYPT_UNLOADCTX_REQ,inBytes,inBytes,inData,inData), Read, NULL},
            {"outData",     STD_OFFSETS(ARC4_LOADKEY_CRYPT_UNLOADCTX_REQ,inBytes,inBytes,outData,outData), Write, NULL},
            {"outCtxData",  STD_OFFSETS(ARC4_LOADKEY_CRYPT_UNLOADCTX_REQ,outCtxBytes,outCtxBytes,outCtxData,outCtxData), Write, ChkArcCtxLen},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_HASH_LDCTX_HASH_ULCTX_GROUP */
    {
        DPD_HASH_LDCTX_HASH_ULCTX_GROUP, "DPD_HASH_LDCTX_HASH_ULCTX_GROUP",
        sizeof(HASH_REQ), sec2_MdhaReq,
        offsetof(HASH_REQ,inBytes),
        {
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"ctxData",     STD_OFFSETS(HASH_REQ,ctxBytes,outBytes,ctxData,outData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"inData",      STD_OFFSETS(HASH_REQ,inBytes,inBytes,inData,inData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"outData",     STD_OFFSETS(HASH_REQ,outBytes,outBytes,outData,outData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_HASH_LDCTX_HASH_PAD_ULCTX_GROUP */
    {
        DPD_HASH_LDCTX_HASH_PAD_ULCTX_GROUP, "DPD_HASH_LDCTX_HASH_PAD_ULCTX_GROUP",
        sizeof(HASH_REQ), sec2_MdhaPadReq,
        offsetof(HASH_REQ,inBytes),
        {
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"ctxData",     STD_OFFSETS(HASH_REQ,ctxBytes,ctxBytes,ctxData,ctxData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"inData",      STD_OFFSETS(HASH_REQ,inBytes,inBytes,inData,inData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"outData",     STD_OFFSETS(HASH_REQ,outBytes,outBytes,outData,outData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_HASH_LDCTX_HMAC_ULCTX_GROUP */
    {
        DPD_HASH_LDCTX_HMAC_ULCTX_GROUP, "DPD_HASH_LDCTX_HMAC_ULCTX_GROUP",
        sizeof(HMAC_PAD_REQ), HmacPadReq,
        offsetof(HMAC_PAD_REQ,inBytes),
        {
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"keyData",     STD_OFFSETS(HMAC_PAD_REQ,keyBytes,keyBytes,keyData,keyData), Read, NULL},
            {"inData",      STD_OFFSETS(HMAC_PAD_REQ,inBytes,inBytes,inData,inData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"outData",     STD_OFFSETS(HMAC_PAD_REQ,outBytes,outBytes,outData,outData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_MM_LDCTX_EXP_ULCTX_GROUP */
    {
        DPD_MM_LDCTX_EXP_ULCTX_GROUP, "DPD_MM_LDCTX_EXP_ULCTX_GROUP",
        sizeof(MOD_EXP_REQ), sec2_PkhaMmExpReq,
        offsetof(MOD_EXP_REQ,outBytes),
        {
            {"modData",     STD_OFFSETS(MOD_EXP_REQ,modBytes,modBytes,modData,modData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"aData",       STD_OFFSETS(MOD_EXP_REQ,aDataBytes,aDataBytes,aData,aData), Read, NULL},
            {"expData",     STD_OFFSETS(MOD_EXP_REQ,expBytes,expBytes,expData,expData), Read, NULL},
            {"outData",     STD_OFFSETS(MOD_EXP_REQ,outBytes,outBytes,outData,outData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
  
  
    
    /* DPD_MM_SS_RSA_EXP */
    {
        DPD_MM_SS_RSA_EXP, "DPD_MM_SS_RSA_EXP",
        sizeof(MOD_SS_EXP_REQ), sec2_PkhaMmSsExpReq,
        0,
        {
            {"modData",STD_OFFSETS(MOD_SS_EXP_REQ,modBytes,modBytes,modData,modData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"aData",STD_OFFSETS(MOD_SS_EXP_REQ,aDataBytes,aDataBytes,aData,aData), Read, NULL},
            {"expData",STD_OFFSETS(MOD_SS_EXP_REQ,expBytes,expBytes,expData,expData), Read, NULL},
            {"bData",STD_OFFSETS(MOD_SS_EXP_REQ,bDataBytes,bDataBytes,bData,bData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_MM_LDCTX_R2MODN_ULCTX_GROUP */
    {
        DPD_MM_LDCTX_R2MODN_ULCTX_GROUP, "DPD_MM_LDCTX_R2MODN_ULCTX_GROUP",
        sizeof(MOD_R2MODN_REQ), PkhaModR2modnReq,
        offsetof(MOD_R2MODN_REQ,outBytes),
        {
            {"modData",     STD_OFFSETS(MOD_R2MODN_REQ,modBytes,modBytes,modData,modData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"outData",     STD_OFFSETS(MOD_R2MODN_REQ,outBytes,outBytes,outData,outData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_MM_LDCTX_RRMODP_ULCTX_GROUP */
    {
        DPD_MM_LDCTX_RRMODP_ULCTX_GROUP, "DPD_MM_LDCTX_RRMODP_ULCTX_GROUP",
        sizeof(MOD_RRMODP_REQ), sec2_PkhaMmRrmodpReq,
        offsetof(MOD_RRMODP_REQ,outBytes),
        {
            {"pData",       STD_OFFSETS(MOD_RRMODP_REQ,pBytes,pBytes,pData,pData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"nBytes",      NULL_PTR_OFFSETS(MOD_RRMODP_REQ,nBytes,nBytes), Read, NULL},
            {"outData",     STD_OFFSETS(MOD_RRMODP_REQ,outBytes,outBytes,outData,outData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_MM_LDCTX_2OP_ULCTX_GROUP */
    {
        DPD_MOD_LDCTX_2OP_ULCTX_GROUP, "DPD_MOD_LDCTX_2OP_ULCTX_GROUP",
        sizeof(MOD_2OP_REQ), PkhaMod2OpReq,
        offsetof(MOD_2OP_REQ,outBytes),
        {
            {"modData",     STD_OFFSETS(MOD_2OP_REQ,modBytes,modBytes,modData,modData), Read, NULL},
            {"bData",       STD_OFFSETS(MOD_2OP_REQ,bDataBytes,bDataBytes,bData,bData), Read, NULL},
            {"aData",       STD_OFFSETS(MOD_2OP_REQ,aDataBytes,aDataBytes,aData,aData), Read, NULL},
            {NIL,           ALL_ZERO_OFFSETS, Read, NULL},
            {"outData",     STD_OFFSETS(MOD_2OP_REQ,outBytes,outBytes,outData,outData), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_EC_LDCTX_kP_ULCTX_GROUP */
    {
        DPD_EC_LDCTX_kP_ULCTX_GROUP, "DPD_EC_LDCTX_kP_ULCTX_GROUP",
        sizeof(ECC_POINT_REQ), PkhaEccPointReq,
        offsetof(ECC_POINT_REQ, b3DataBytes),
        {
            {"nData", STD_OFFSETS(ECC_POINT_REQ,nDataBytes,nDataBytes,nData,nData), Read, NULL},
            {"eData", STD_OFFSETS(ECC_POINT_REQ,eDataBytes,eDataBytes,eData,eData), Read, NULL},
            {"buildData", STD_OFFSETS(ECC_POINT_REQ,buildDataBytes,buildDataBytes,buildData,buildData), Read, NULL},
            {"b1Data", STD_OFFSETS(ECC_POINT_REQ,b1DataBytes,b1DataBytes,b1Data,b1Data), Write, NULL},
            {"b2Data", STD_OFFSETS(ECC_POINT_REQ,b2DataBytes,b2DataBytes,b2Data,b2Data), Write, NULL},
            {"b3Data", STD_OFFSETS(ECC_POINT_REQ,b3DataBytes,b3DataBytes,b3Data,b3Data), Write, NULL},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },
    
    
    
    
    /* DPD_EC_2OP_GROUP */
    {
        DPD_EC_2OP_GROUP, "DPD_EC_2OP_GROUP",
        sizeof(ECC_2OP_REQ), sec2_PkhaEcc2OpReq,
        offsetof(ECC_2OP_REQ,outBytes),
        {
            {"bData",       STD_OFFSETS(ECC_2OP_REQ,bDataBytes,bDataBytes,bData,bData), Read, ChkEccLen},
            {"aData",       STD_OFFSETS(ECC_2OP_REQ,aDataBytes,aDataBytes,aData,aData), Read, ChkEccLen},
            {"modData",     STD_OFFSETS(ECC_2OP_REQ,modBytes,modBytes,modData,modData), Read, ChkEccLen},
            {"outData",     STD_OFFSETS(ECC_2OP_REQ,outBytes,outBytes,outData,outData), Write, ChkEccLen},
            {NULL, ALL_ZERO_OFFSETS, Read, NULL}
        },
    },




    /* DPD_EC_SPKBUILD_GROUP */
    {
        DPD_EC_SPKBUILD_GROUP, "DPD_EC_SPKBUILD_GROUP",
        sizeof(ECC_SPKBUILD_REQ), PkhaEccSpkbuildReq,
        offsetof(ECC_SPKBUILD_REQ, buildDataBytes),
        {
            {"a0Data", STD_OFFSETS(ECC_SPKBUILD_REQ,a0DataBytes,a0DataBytes,a0Data,a0Data), Read, NULL},
            {"a1Data", STD_OFFSETS(ECC_SPKBUILD_REQ,a1DataBytes,a1DataBytes,a1Data,a1Data), Read, NULL},
            {"a2Data", STD_OFFSETS(ECC_SPKBUILD_REQ,a2DataBytes,a2DataBytes,a2Data,a2Data), Read, NULL},
            {"a3Data", STD_OFFSETS(ECC_SPKBUILD_REQ,a3DataBytes,a3DataBytes,a3Data,a3Data), Read, NULL},
            {"b0Data", STD_OFFSETS(ECC_SPKBUILD_REQ,b0DataBytes,b0DataBytes,b0Data,b0Data), Read, NULL},
            {"b1Data", STD_OFFSETS(ECC_SPKBUILD_REQ,b1DataBytes,b1DataBytes,b1Data,b1Data), Read, NULL},
            {"buildData", STD_OFFSETS(ECC_SPKBUILD_REQ,buildDataBytes,buildDataBytes,buildData,buildData), Write, NULL},
        },
    },




    /* DPD_EC_PTADD_DBL_GROUP */
    {
        DPD_EC_PTADD_DBL_GROUP, "DPD_EC_PTADD_DBL_GROUP",
        sizeof(ECC_PTADD_DBL_REQ), PkhaEccPtaddDblReq,
        offsetof(ECC_PTADD_DBL_REQ, b3DataBytes),
        {
            {"modData",   STD_OFFSETS(ECC_PTADD_DBL_REQ,modBytes,modBytes,modData,modData),                 Read, NULL},
            {"buildData", STD_OFFSETS(ECC_PTADD_DBL_REQ,buildDataBytes,buildDataBytes,buildData,buildData), Read, NULL},
            {"b2InData",  STD_OFFSETS(ECC_PTADD_DBL_REQ,b2InDataBytes,b2InDataBytes,b2InData,b2InData),     Read, NULL},
            {"b3InData",  STD_OFFSETS(ECC_PTADD_DBL_REQ,b3InDataBytes,b3InDataBytes,b3InData,b3InData),     Read, NULL},
            {"b1Data",    STD_OFFSETS(ECC_PTADD_DBL_REQ,b1DataBytes,b1DataBytes,b1Data,b1Data),             Write, NULL},