sec2_test.c

freescale ppc sec2加解密单元驱动

    free(hash->inData);
    free(hash->outData);

    return;
}


/**********************************************************************************/
void sec2_test_hash_sha_callback(void *ctx)
{
    algo_msg_ike_hash_t *hash_msg = NULL;
    algo_msg_hash_t *hash = NULL;

    if (ctx == NULL)
    {
        printf("test_md5_callback: null ctx!\n");
        return;
    }

    hash_msg = (algo_msg_ike_hash_t *)ctx;
    hash = &(hash_msg->msgHash);
#if 0
    printf("MPC190 HASH MD5 RESULT:\n");
    for (i = 0; i < hash->outLen; i++)
    {
        printf("%02x ",*(hash->outData + i));
        if ((i + 1) % 20 == 0)
        {
            printf("\n");
        }
    }
    printf("\n");


    memset(hash->outData, 0, hash->outLen);
    /*crypto_hash_md5(hash);*/
    printf("isws output:\n");
    for (i = 0; i < hash->outLen; i++)
    {
        printf("%02x ", *(hash->outData + i));
    }
    printf("\n");

#endif
    free(hash->inData);
    free(hash->outData);

    return;
}

void sec2_test_hash_sha_err_callback(void *ctx)
{
    algo_msg_ike_hash_t *hash_msg = NULL;
    algo_msg_hash_t *hash = NULL;

    if (ctx == NULL)
    {
        printf("test_md5_err_callback: null ctx!\n");
        return;
    }

    hash_msg = (algo_msg_ike_hash_t *)ctx;
    hash = &(hash_msg->msgHash);

    free(hash->inData);
    free(hash->outData);

    return;
}


/***************************************************************/
void sec2_test_hmac_sha_callback(void *ctx)
{
    algo_msg_ike_hmac_t *hmac_msg = NULL;
    algo_msg_hmac_t *hmac = NULL;

    if (ctx == NULL)
    {
        printf("test_sha_callback: null ctx!\n");
        return;
    }

    hmac_msg = (algo_msg_ike_hmac_t *)ctx;
    hmac = &(hmac_msg->msgHmac);
#if 0
    printf("MPC190 HMAC SHA RESULT:\n");
    for (i = 0; i < hmac->outLen; i++)
    {
        printf("%02x ",*(hmac->outData + i));
        if ((i + 1) % 20 == 0)
        {
            printf("\n");
        }
    }
    printf("\n");

    memset(hmac->outData, 0, hmac->outLen);
    /*crypto_hmac_sha1(hmac);*/
    printf("isws output:\n");
    for (i = 0; i < hmac->outLen; i++)
    {
        printf("%02x ", *(hmac->outData + i));
    }
    printf("\n");
#endif
    free(hmac->inData);
    free(hmac->outData);
    free(hmac->key);

    return;
}

void sec2_test_hmac_sha_err_callback(void *ctx)
{
    algo_msg_ike_hmac_t *hmac_msg = NULL;
    algo_msg_hmac_t *hmac = NULL;

    if (ctx == NULL)
    {
        printf("test_sha_err_callback: null ctx!\n");
        return;
    }

    hmac_msg = (algo_msg_ike_hmac_t *)ctx;
    hmac = &(hmac_msg->msgHmac);

    free(hmac->inData);
    free(hmac->outData);
    free(hmac->key);

    return;
}




void sec2_test_hmac_md5_callback(void *ctx)
{
    algo_msg_ike_hmac_t *hmac_msg = NULL;
    algo_msg_hmac_t *hmac = NULL;

    if (ctx == NULL)
    {
        printf("test_sha_callback: null ctx!\n");
        return;
    }

    hmac_msg = (algo_msg_ike_hmac_t *)ctx;
    hmac = &(hmac_msg->msgHmac);
#if 0
    printf("MPC190 HMAC SHA RESULT:\n");
    for (i = 0; i < hmac->outLen; i++)
    {
        printf("%02x ",*(hmac->outData + i));
        if ((i + 1) % 20 == 0)
        {
            printf("\n");
        }
    }
    printf("\n");

    memset(hmac->outData, 0, hmac->outLen);
    /*crypto_hmac_sha1(hmac);*/
    printf("isws output:\n");
    for (i = 0; i < hmac->outLen; i++)
    {
        printf("%02x ", *(hmac->outData + i));
    }
    printf("\n");
#endif
    free(hmac->inData);
    free(hmac->outData);
    free(hmac->key);

    return;
}

void sec2_test_hmac_md5_err_callback(void *ctx)
{
    algo_msg_ike_hmac_t *hmac_msg = NULL;
    algo_msg_hmac_t *hmac = NULL;

    if (ctx == NULL)
    {
        printf("test_sha_err_callback: null ctx!\n");
        return;
    }

    hmac_msg = (algo_msg_ike_hmac_t *)ctx;
    hmac = &(hmac_msg->msgHmac);

    free(hmac->inData);
    free(hmac->outData);
    free(hmac->key);

    return;
}

/*下面是各种算法的测试函数*/
void sec2_test_rng(int len)
{
    algo_msg_ike_rng_t * rng_msg = NULL;    /*第三个参数，随即数的消息结构*/
    algo_msg_rng_t *rng          = NULL;    /*第二个参数,随即数的参数结构*/
    DRV_LNDEC_ALG_REQ_PARA* arg_in  = NULL; /*写消息结构，分配地址空间*/

    rng_msg = (algo_msg_ike_rng_t *)OsAlloc(sizeof(algo_msg_ike_rng_t));

    if (rng_msg == NULL)    /*如果消息消息为空，报错*/
    {
        printf("mpc190_test_rng: failed to malloc rng_msg!\n");
        return;
    }
   /*消息头部分*/
    rng_msg->msgHdr.algoid = ALGO_IKE_RNG;
    rng_msg->msgHdr.callback = sec2_test_rng_callback;
    rng_msg->msgHdr.ctx = rng_msg;
    rng_msg->msgHdr.error_callback = sec2_test_rng_err_callback;
    rng_msg->msgHdr.ISSC_num = 0;
    rng_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;  /*算法完成后返回的消息类型*/

   /*结构部分*/
    rng = &(rng_msg->msgRng);                       /*指向结构部分地址*/
    rng->dataLen = len;
    rng->outData = malloc(rng->dataLen);            /*申请32 字节地址空间*/
    /*检测是否为空*/
    if (rng->outData == NULL)
    {
        printf("mpc190_test_rng: malloc param failed!\n");
        OsFree(rng_msg);
        return;
    }
    memset(rng->outData , 0, rng->dataLen);

    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(rng_msg);
        return;
    }
    memset(arg_in , 0, (sizeof(DRV_LNDEC_ALG_REQ_PARA)));
    arg_in->rng  = rng;
    arg_in->data = rng_msg ;

    /*下发驱动处理*/
   drv_sec2_rng_num(DRV_IPSEC_RNG_NUM, arg_in);
   
   return;
}

void sec2_test_des_encrypt(int count, int len)
{
    algo_msg_ike_cbc_t *cbc_msg = NULL;                   /*第三个参数*/
    algo_msg_crypt_t *cbc = NULL;                         /*第二个参数*/
    UINT8 pt3[8] = "01234567";                            /*KEY */
    int      i;
    DRV_LNDEC_ALG_REQ_PARA* arg_in  = NULL; /*写消息结构，分配地址空间*/
    
    cbc_msg = (algo_msg_ike_cbc_t *)OsAlloc(sizeof(algo_msg_ike_cbc_t));
    if (cbc_msg == NULL)
    {
        printf("mpc190_test_des: failed to malloc hash_msg!\n");
        return;
    }
    cbc_msg->msgHdr.algoid = ALGO_IKE_CBC_ENCRYPT_DES;           /*CBC DES*/
    cbc_msg->msgHdr.callback = sec2_test_des_callback;
    cbc_msg->msgHdr.ctx = cbc_msg;
    cbc_msg->msgHdr.error_callback = sec2_test_des_err_callback;
    cbc_msg->msgHdr.ISSC_num = 0;
    cbc_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;

    cbc = &(cbc_msg->msgCrypt);

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

    memset(cbc->inData, 0x67, cbc->inLen);                    /*输入数据,128 位*/
    cbc->keyLen = 8;                                                        /*输入密钥长度*/
    cbc->key = malloc(cbc->keyLen);                /*分配内存空间*/
    if (cbc->key == NULL)
    {
        printf("mpc190_test_des: failed to malloc key!\n");
        free(cbc->inData);
        OsFree(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 malloc iv!\n");
        free(cbc->inData);
        free(cbc->key);
        OsFree(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 malloc outData!\n");
        free(cbc->inData);
        free(cbc->key);
        free(cbc->iv);
        OsFree(cbc_msg);
        return;
    }
    memset(cbc->outData, 0, len);
    
    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_msg);
        return;
    }
    memset(arg_in , 0, (sizeof(DRV_LNDEC_ALG_REQ_PARA)));
    arg_in->crypt = cbc;
    arg_in->data  = cbc_msg ;

    /*下发驱动*/
    for(i=0;i<count;i++)
    {
      drv_sec2_des_crypt(DRV_IPSEC_DES_ENCRYPT, arg_in);
      
      taskDelay(1);      
    
      if(mpc190CardNo > 0)
        {
            mpc190_test_des_encrypt128_normal(count,len);
            
            taskDelay(1);       /*单元测试debug版本不需要提供性能测试，延时等待输出*/
            
            if(0 == memcmp(drv_ipsec_out_lndec,drv_ipsec_out_internalSec2,len))
            {
                drv_ipsec_success_num++;
            }
            else
            {
                drv_ipsec_error_num++;
            }  
        }
      }
    return;
}

/************************************************************************/
void sec2_test_des_decrypt(int count, int len)
{
    int i;
    UINT8 pt3[8] = "01234567";                            /*KEY */
    algo_msg_ike_cbc_t *cbc_msg = NULL;           /*第三个参数*/
    algo_msg_crypt_t *cbc = NULL;                 /*第二个参数*/
    DRV_LNDEC_ALG_REQ_PARA* arg_in  = NULL;       /*写消息结构，分配地址空间*/
    
    cbc_msg = (algo_msg_ike_cbc_t *)OsAlloc(sizeof(algo_msg_ike_cbc_t));
    if (cbc_msg == NULL)
    {
        printf("mpc190_test_des: failed to malloc hash_msg!\n");
        return;
    }
    cbc_msg->msgHdr.algoid = ALGO_IKE_CBC_DECRYPT_DES;           /*CBC DES 解密*/
    cbc_msg->msgHdr.callback = sec2_test_des_callback;
    cbc_msg->msgHdr.ctx = cbc_msg;
    cbc_msg->msgHdr.error_callback = sec2_test_des_err_callback;
    cbc_msg->msgHdr.ISSC_num = 0;
    cbc_msg->msgHdr.reply_msgId = MSG_IKE_ALGO_OK;

    cbc = &(cbc_msg->msgCrypt);

    cbc->inLen = len;                                            /*输入数据长度*/
    cbc->inData = drv_ipsec_out_internalSec2;

    cbc->keyLen = 8;                                                        /*输入密钥长度*/
    cbc->key = malloc(cbc->keyLen);                /*分配内存空间*/
    if (cbc->key == NULL)
    {
        printf("mpc190_test_des: failed to malloc key!\n");
        free(cbc->inData);
        OsFree(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 malloc iv!\n");
        free(cbc->inData);
        free(cbc->key);
        OsFree(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 malloc outData!\n");
        free(cbc->inData);
        free(cbc->key);
        free(cbc->iv);
        OsFree(cbc_msg);
        return;
    }
    memset(cbc->outData, 0, len);

    arg_in =(DRV_LNDEC_ALG_REQ_PARA*) malloc(sizeof(DRV_LNDEC_ALG_REQ_PARA));   
    /*检测是否为空*/
    if (arg_in == NULL)