sec2_test.c

freescale ppc sec2加解密单元驱动

    memset(arg_in , 0, (sizeof(DRV_LNDEC_ALG_REQ_PARA)));
    arg_in->auth = hmac;
    arg_in->data = hmac_msg ;
    
    for(i = 0; i<count; i ++)
    {
       drv_sec2_hmac_auth(DRV_IPSEC_HMAC_SHA_AUTH, arg_in);        
    }  
    return;
}

void sec2_test_hmac_sha256(int count,int len)
{
    algo_msg_ike_hmac_t *hmac_msg = NULL;
    algo_msg_hmac_t *hmac = NULL;
    UINT8 pt3[32] = "01234567890123456789012345678901";
    int i;
    DRV_LNDEC_ALG_REQ_PARA* arg_in  = NULL; /*写消息结构，分配地址空间*/

    hmac_msg = (algo_msg_ike_hmac_t *)OsAlloc(sizeof(algo_msg_ike_hmac_t));
    if (hmac_msg == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to malloc hash_msg!\n");
        return;
    }
    hmac_msg->msgHdr.algoid = ALGO_IKE_HMAC_SHA;
    hmac_msg->msgHdr.callback = sec2_test_hmac_sha_callback;
    hmac_msg->msgHdr.ctx = hmac_msg;
    hmac_msg->msgHdr.error_callback = sec2_test_hmac_sha_err_callback;
    hmac_msg->msgHdr.ISSC_num = 0;
    hmac_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;
    /*ike_get_pid(&(hmac_msg->msgHdr.sender));*/

    hmac = &(hmac_msg->msgHmac);

    hmac->inLen = len;
    hmac->inData = malloc(hmac->inLen);
    if (hmac->inData == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to malloc inData!\n");
        OsFree(hmac_msg);
        return;
    }
    memset(hmac->inData, 0x39, hmac->inLen);

    hmac->keyLen = 32;
    hmac->key = malloc(hmac->keyLen);
    if (hmac->key == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to malloc key!\n");
        free(hmac->inData);
        OsFree(hmac_msg);
        return;
    }
    memcpy(hmac->key, pt3, hmac->keyLen);

    hmac->outLen = 32;
    hmac->outData = malloc(hmac->outLen);
    if (hmac->outData == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to malloc outData!\n");
        free(hmac->inData);
        free(hmac->key);
        OsFree(hmac_msg);
        return;
    }
    memset(hmac->outData,0, hmac->outLen);

    arg_in =(DRV_LNDEC_ALG_REQ_PARA*) malloc(sizeof(DRV_LNDEC_ALG_REQ_PARA));   
    /*检测是否为空*/
    if (arg_in == NULL)
    {
        printf("mpc190_test_rng: malloc param failed!\n");
        OsFree(hmac_msg);
        return;
    }
    memset(arg_in , 0, (sizeof(DRV_LNDEC_ALG_REQ_PARA)));
    arg_in->auth = hmac;
    arg_in->data = hmac_msg ;
    
    for(i = 0; i<count; i ++)
    {
       drv_sec2_hmac_auth(DRV_IPSEC_HMAC_SHA256_AUTH, arg_in);
    }

    return;
}


void sec2_test_des_hmac_encrypt(int len, int choose)
{
    algo_msg_crypt_t *cbc = NULL;
    algo_msg_hmac_t *hmac = NULL;
    algo_msg_ike_cbc_hmac_t *cbc_hmac_msg = NULL;
    DRV_LNDEC_ALG_REQ_PARA* arg_in  = NULL; /*写消息结构，分配地址空间*/
    
    UINT8 pt3[8] = "01234567";                       /*DES-KEY */
    UINT8 pt4[20] = "01234567890123456789";  /*认证密钥*/
    cbc_hmac_msg = (algo_msg_ike_cbc_hmac_t *)malloc(sizeof(algo_msg_ike_cbc_hmac_t));
    cbc_hmac_msg->cbc_msg = (algo_msg_ike_cbc_t *)malloc(sizeof(algo_msg_ike_cbc_t));
    if (cbc_hmac_msg->cbc_msg == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc hash_msg!\n");
        return;
    }
    cbc_hmac_msg->cbc_msg->msgHdr.algoid = ALGO_IKE_HMAC_SHA;
    cbc_hmac_msg->cbc_msg->msgHdr.callback = sec2_test_des_callback;
    cbc_hmac_msg->cbc_msg->msgHdr.ctx = cbc_hmac_msg->cbc_msg;
    cbc_hmac_msg->cbc_msg->msgHdr.error_callback = sec2_test_des_err_callback;
    cbc_hmac_msg->cbc_msg->msgHdr.ISSC_num = 0;
    cbc_hmac_msg->cbc_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;    /*输出*/



    /*des 部分*/
    cbc = &(cbc_hmac_msg->cbc_msg->msgCrypt);

    cbc->inLen = len;                                                      /*输入数据长度*/
    cbc->inData = malloc(cbc->inLen);               /*分配输入内存*/
    if (cbc->inData == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc inData!\n");
        OsFree(cbc_hmac_msg->cbc_msg);
        return;
    }
    memset(cbc->inData, 0x67, cbc->inLen);                    /*输入数据,64 位*/
	
    cbc->keyLen = 8;                                      /*输入密钥长度*/
    cbc->key = malloc(cbc->keyLen);                /*分配内存空间*/
    if (cbc->key == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc key!\n");
        free(cbc->inData);
        OsFree(cbc_hmac_msg->cbc_msg);
        return;
    }
    memcpy(cbc->key, pt3, cbc->keyLen);                      /*输入密钥*/

    cbc->ivlen = 8;                                                           /*初始化向量长度*/
    cbc->iv = malloc(cbc->ivlen);
    if (cbc->iv == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc iv!\n");
        free(cbc->inData);
        free(cbc->key);
        OsFree(cbc_hmac_msg->cbc_msg);
        return;
    }
    memcpy(cbc->iv, pt3, cbc->ivlen);                            /*初始化向量赋值*/

    cbc->outLen = len;
    cbc->outData = malloc(cbc->outLen);         /*分配输出内存*/
    if (cbc->outData == NULL)                                          /*如果分配失败则释放*/
    {
        printf("mpc190_test_des: failed to sec2_malloc outData!\n");
        free(cbc->inData);
        free(cbc->key);
        free(cbc->iv);
        OsFree(cbc_hmac_msg->cbc_msg);
        return;
    }

     /*hmac 认证部分*/
    cbc_hmac_msg->hmac_msg = (algo_msg_ike_hmac_t *)malloc(sizeof(algo_msg_ike_hmac_t));
    if (cbc_hmac_msg->hmac_msg == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to sec2_malloc hash_msg!\n");
        return;
    }
    cbc_hmac_msg->hmac_msg->msgHdr.algoid = ALGO_IKE_HMAC_SHA;
    cbc_hmac_msg->hmac_msg->msgHdr.callback = sec2_test_hmac_md5_callback;
    cbc_hmac_msg->hmac_msg->msgHdr.ctx = cbc_hmac_msg->hmac_msg;
    cbc_hmac_msg->hmac_msg->msgHdr.error_callback = sec2_test_hmac_md5_err_callback;
    cbc_hmac_msg->hmac_msg->msgHdr.ISSC_num = 0;
    cbc_hmac_msg->hmac_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;

    hmac = &(cbc_hmac_msg->hmac_msg->msgHmac);

    hmac->inLen = len;
    hmac->inData =  cbc->inData;

    hmac->keyLen = 20;
    hmac->key = malloc(hmac->keyLen);
    if (hmac->key == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to sec2_malloc key!\n");
        free(hmac->inData);
        OsFree(cbc_hmac_msg->hmac_msg);
        return;
    }
    memset(hmac->key,0,64);
    memcpy(hmac->key, pt4, hmac->keyLen);


    if(choose == 1)
        hmac->outLen = 16;
    if(choose == 2)
        hmac->outLen = 20;
    if(choose == 3)
        hmac->outLen = 32;
    hmac->outData = malloc(hmac->outLen);
    
    if (hmac->outData == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to sec2_malloc outData!\n");
        free(hmac->inData);
        free(hmac->key);
        OsFree(cbc_hmac_msg->hmac_msg);
        return;
    }

    arg_in =(DRV_LNDEC_ALG_REQ_PARA*) malloc(sizeof(DRV_LNDEC_ALG_REQ_PARA));   
    /*检测是否为空*/
    if (arg_in == NULL)
    {
        printf("mpc190_test_rng: malloc param failed!\n");
        OsFree(cbc_hmac_msg);
        return;
    }
    memset(arg_in , 0, (sizeof(DRV_LNDEC_ALG_REQ_PARA)));
    arg_in->auth  = hmac;
    arg_in->crypt = cbc;
    arg_in->data  = cbc_hmac_msg ;

    /*下发驱动*/
    if(choose == 1)
    {
        drv_sec2_des_hmac_crypt(DRV_IPSEC_DES_HMAC_MD5_ENCRYPT, arg_in);
    }
    if(choose == 2)
    {
        drv_sec2_des_hmac_crypt(DRV_IPSEC_DES_HMAC_SHA_ENCRYPT, arg_in);
    }
    if(choose == 3)
    drv_sec2_des_hmac_crypt(DRV_IPSEC_DES_HMAC_SHA256_ENCRYPT,arg_in);
    return;
}

void sec2_test_3des_hmac_encrypt(int len, int choose)
{
    algo_msg_crypt_t *cbc = NULL;
    algo_msg_hmac_t *hmac = NULL;
    algo_msg_ike_cbc_hmac_t *cbc_hmac_msg = NULL;
    DRV_LNDEC_ALG_REQ_PARA* arg_in  = NULL; /*写消息结构，分配地址空间*/

    UINT8 pt3[8] = "01234567";                       /*DES-KEY */
    UINT8 pt4[20] = "01234567890123456789";          /*认证密钥*/
    UINT8 pt5[24] = "012345678901234567890123";
    cbc_hmac_msg = (algo_msg_ike_cbc_hmac_t *)malloc(sizeof(algo_msg_ike_cbc_hmac_t));
    cbc_hmac_msg->cbc_msg = (algo_msg_ike_cbc_t *)malloc(sizeof(algo_msg_ike_cbc_t));
    if (cbc_hmac_msg->cbc_msg == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc hash_msg!\n");
        return;
    }
    cbc_hmac_msg->cbc_msg->msgHdr.algoid = ALGO_IKE_HMAC_SHA;
    cbc_hmac_msg->cbc_msg->msgHdr.callback = sec2_test_des_callback;
    cbc_hmac_msg->cbc_msg->msgHdr.ctx = cbc_hmac_msg->cbc_msg;
    cbc_hmac_msg->cbc_msg->msgHdr.error_callback = sec2_test_des_err_callback;
    cbc_hmac_msg->cbc_msg->msgHdr.ISSC_num = 0;
    cbc_hmac_msg->cbc_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;    /*输出*/



    /*des 部分*/
    cbc = &(cbc_hmac_msg->cbc_msg->msgCrypt);

    cbc->inLen = len;                                                      /*输入数据长度*/
    cbc->inData = malloc(cbc->inLen);               /*分配输入内存*/
    if (cbc->inData == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc inData!\n");
        OsFree(cbc_hmac_msg->cbc_msg);
        return;
    }
    memset(cbc->inData, 0x67, cbc->inLen);                    /*输入数据,64 位*/
	
    cbc->keyLen = 24;                                      /*输入密钥长度*/
    cbc->key = malloc(cbc->keyLen);                /*分配内存空间*/
    if (cbc->key == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc key!\n");
        free(cbc->inData);
        OsFree(cbc_hmac_msg->cbc_msg);
        return;
    }
    memcpy(cbc->key, pt5, cbc->keyLen);                      /*输入密钥*/

    cbc->ivlen = 8;                                                           /*初始化向量长度*/
    cbc->iv = malloc(cbc->ivlen);
    if (cbc->iv == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc iv!\n");
        free(cbc->inData);
        free(cbc->key);
        OsFree(cbc_hmac_msg->cbc_msg);
        return;
    }
    memcpy(cbc->iv, pt3, cbc->ivlen);                            /*初始化向量赋值*/

    cbc->outLen = len;
    cbc->outData = malloc(cbc->outLen);         /*分配输出内存*/
    if (cbc->outData == NULL)                                          /*如果分配失败则释放*/
    {
        printf("mpc190_test_des: failed to sec2_malloc outData!\n");
        free(cbc->inData);
        free(cbc->key);
        free(cbc->iv);
        OsFree(cbc_hmac_msg->cbc_msg);
        return;
    }


     /*hmac 认证部分*/
    cbc_hmac_msg->hmac_msg = (algo_msg_ike_hmac_t *)malloc(sizeof(algo_msg_ike_hmac_t));
    if (cbc_hmac_msg->hmac_msg == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to sec2_malloc hash_msg!\n");
        return;
    }
    cbc_hmac_msg->hmac_msg->msgHdr.algoid = ALGO_IKE_HMAC_SHA;
    cbc_hmac_msg->hmac_msg->msgHdr.callback = sec2_test_hmac_md5_callback;
    cbc_hmac_msg->hmac_msg->msgHdr.ctx = cbc_hmac_msg->hmac_msg;
    cbc_hmac_msg->hmac_msg->msgHdr.error_callback = sec2_test_hmac_md5_err_callback;
    cbc_hmac_msg->hmac_msg->msgHdr.ISSC_num = 0;
    cbc_hmac_msg->hmac_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;

    hmac = &(cbc_hmac_msg->hmac_msg->msgHmac);

    hmac->inLen = len;
    hmac->inData =  cbc->inData;

    hmac->keyLen = 20;
    hmac->key = malloc(hmac->keyLen);
    if (hmac->key == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to sec2_malloc key!\n");
        free(hmac->inData);
        OsFree(cbc_hmac_msg->hmac_msg);
        return;
    }
    memset(hmac->key,0,64);
    memcpy(hmac->key, pt4, hmac->keyLen);

    
    if(choose == 1)
        hmac->outLen = 16;
    if(choose == 2)
        hmac->outLen = 20;
    if(choose == 3)
        hmac->outLen = 32;
    hmac->outData = malloc(hmac->outLen);
    
    if (hmac->outData == NULL)
    {
        printf("mpc190_test_hmac_sha: failed to sec2_malloc outData!\n");
        free(hmac->inData);
        free(hmac->key);
        OsFree(cbc_hmac_msg->hmac_msg);
        return;
    }

    arg_in =(DRV_LNDEC_ALG_REQ_PARA*) malloc(sizeof(DRV_LNDEC_ALG_REQ_PARA));   
    /*检测是否为空*/
    if (arg_in == NULL)
    {
        printf("mpc190_test_rng: malloc param failed!\n");
        OsFree(cbc_hmac_msg);
        return;
    }
    memset(arg_in , 0, (sizeof(DRV_LNDEC_ALG_REQ_PARA)));
    arg_in->auth  = hmac;
    arg_in->crypt = cbc;
    arg_in->data  = cbc_hmac_msg ;
    
    if(choose == 1)
    {
        drv_sec2_des_hmac_crypt(DRV_IPSEC_3DES_HMAC_MD5_ENCRYPT, arg_in);
    }
    if(choose == 2)
    drv_sec2_des_hmac_crypt(DRV_IPSEC_3DES_HMAC_SHA_ENCRYPT, arg_in);
    if(choose == 3)
    drv_sec2_des_hmac_crypt(DRV_IPSEC_3DES_HMAC_SHA256_ENCRYPT, arg_in);
    /*下发驱动*/
    return;
}


void sec2_test_aes_hmac_encrypt(int len, int choose)
{
    algo_msg_crypt_t *cbc = NULL;
    algo_msg_hmac_t *hmac = NULL;
    algo_msg_ike_cbc_hmac_t *cbc_hmac_msg = NULL;
    DRV_LNDEC_ALG_REQ_PARA* arg_in  = NULL; /*写消息结构，分配地址空间*/

    UINT8 pt3[24] = "012345678901234667890123";                       /*DES-KEY */
    UINT8 pt4[20] = "01234567890123456789";  /*认证密钥*/
    cbc_hmac_msg = (algo_msg_ike_cbc_hmac_t *)malloc(sizeof(algo_msg_ike_cbc_hmac_t));
    cbc_hmac_msg->cbc_msg = (algo_msg_ike_cbc_t *)malloc(sizeof(algo_msg_ike_cbc_t));
    if (cbc_hmac_msg->cbc_msg == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc hash_msg!\n");
        return;
    }
    cbc_hmac_msg->cbc_msg->msgHdr.algoid = ALGO_IKE_HMAC_SHA;
    cbc_hmac_msg->cbc_msg->msgHdr.callback = sec2_test_des_callback;
    cbc_hmac_msg->cbc_msg->msgHdr.ctx = cbc_hmac_msg->cbc_msg;
    cbc_hmac_msg->cbc_msg->msgHdr.error_callback = sec2_test_des_err_callback;
    cbc_hmac_msg->cbc_msg->msgHdr.ISSC_num = 0;
    cbc_hmac_msg->cbc_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;    /*输出*/



    /*des 部分*/
    cbc = &(cbc_hmac_msg->cbc_msg->msgCrypt);

    cbc->inLen = len;                                                      /*输入数据长度*/
    cbc->inData = malloc(cbc->inLen);               /*分配输入内存*/
    if (cbc->inData == NULL)
    {
        printf("mpc190_test_des: failed to sec2_malloc inData!\n");
        OsFree(cbc_hmac_msg->cbc_msg);
        ret