283 lines
6.3 KiB
C
283 lines
6.3 KiB
C
/*
|
|
* Copyright (c) 2022 Rockchip Electronics Co. Ltd.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "rkcrypto_core.h"
|
|
#include "rkcrypto_mem.h"
|
|
#include "rkcrypto_demo.h"
|
|
|
|
#define HASH_MAX_LEN 64
|
|
static uint8_t input[16] = {
|
|
0xc9, 0x07, 0x21, 0x05, 0x80, 0x1b, 0x00, 0x44,
|
|
0xac, 0x13, 0xfb, 0x23, 0x93, 0x4a, 0x66, 0xe4,
|
|
};
|
|
static uint8_t expected_hash[] = {
|
|
0x5e, 0xd1, 0x70, 0xb2, 0x0a, 0xcd, 0xf2, 0x8e,
|
|
0xee, 0x28, 0xd7, 0x70, 0x78, 0x79, 0x2d, 0xf5,
|
|
0x83, 0xba, 0xf4, 0x52, 0xce, 0x3f, 0x71, 0x70,
|
|
0x15, 0x4f, 0x2c, 0x48, 0xbc, 0x51, 0x23, 0x6f,
|
|
};
|
|
static uint8_t expected_hmac[] = {
|
|
0x91, 0xcb, 0x13, 0x85, 0x1e, 0xa1, 0xbb, 0xc2,
|
|
0xa4, 0x0f, 0x79, 0x9f, 0xc8, 0xb1, 0x95, 0x3b,
|
|
0x2d, 0x3f, 0xe7, 0xe4, 0x6d, 0x95, 0x19, 0x34,
|
|
0x97, 0x7f, 0x63, 0x46, 0xff, 0x92, 0xa3, 0x51,
|
|
};
|
|
static uint8_t key[SHA256_BLOCK_SIZE] = {
|
|
0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
|
|
0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
|
|
0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
};
|
|
static uint32_t hash_algo = RK_ALGO_SHA256;
|
|
static uint32_t hmac_algo = RK_ALGO_HMAC_SHA256;
|
|
|
|
RK_RES demo_hash(void)
|
|
{
|
|
RK_RES res = RK_CRYPTO_ERR_GENERIC;
|
|
rk_hash_config hash_cfg;
|
|
rk_handle hash_hdl = 0;
|
|
uint32_t data_len = sizeof(input);
|
|
rk_crypto_mem *in = NULL;
|
|
uint8_t output[HASH_MAX_LEN];
|
|
|
|
|
|
res = rk_crypto_init();
|
|
if (res) {
|
|
printf("rk_crypto_init error! res: 0x%08x\n", res);
|
|
return res;
|
|
}
|
|
|
|
in = rk_crypto_mem_alloc(data_len);
|
|
if (!in) {
|
|
printf("malloc %uByte error!\n", data_len);
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
memcpy(in->vaddr, input, data_len);
|
|
memset(&hash_cfg, 0x00, sizeof(hash_cfg));
|
|
hash_cfg.algo = hash_algo;
|
|
|
|
res = rk_hash_init(&hash_cfg, &hash_hdl);
|
|
if (res) {
|
|
printf("rk_hash_init error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
res = rk_hash_update(hash_hdl, in->dma_fd, in->size);
|
|
if (res) {
|
|
rk_hash_final(hash_hdl, NULL);
|
|
printf("rk_hash_update error = %d\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
rk_hash_final(hash_hdl, output);
|
|
|
|
/* Verify the result */
|
|
if (memcmp(output, expected_hash, sizeof(expected_hash)) != 0) {
|
|
printf("HASH result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
printf("Test HASH success!\n");
|
|
|
|
exit:
|
|
rk_crypto_mem_free(in);
|
|
|
|
rk_crypto_deinit();
|
|
|
|
return res;
|
|
}
|
|
|
|
RK_RES demo_hash_virt(void)
|
|
{
|
|
RK_RES res = RK_CRYPTO_ERR_GENERIC;
|
|
rk_hash_config hash_cfg;
|
|
uint8_t output[HASH_MAX_LEN];
|
|
uint32_t data_len = sizeof(input);
|
|
rk_handle hash_hdl = 0;
|
|
uint32_t data_block = 128;
|
|
uint8_t *tmp_data;
|
|
uint32_t tmp_len;
|
|
|
|
res = rk_crypto_init();
|
|
if (res) {
|
|
printf("rk_crypto_init error! res: 0x%08x\n", res);
|
|
return res;
|
|
}
|
|
|
|
memset(&hash_cfg, 0x00, sizeof(hash_cfg));
|
|
hash_cfg.algo = hash_algo;
|
|
|
|
res = rk_hash_init(&hash_cfg, &hash_hdl);
|
|
if (res) {
|
|
printf("rk_hash_init error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
tmp_len = data_len;
|
|
tmp_data = input;
|
|
|
|
while (tmp_len) {
|
|
if (tmp_len > data_block) {
|
|
res = rk_hash_update_virt(hash_hdl, tmp_data, data_block);
|
|
if (res) {
|
|
rk_hash_final(hash_hdl, NULL);
|
|
printf("rk_hash_update_virt error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
} else {
|
|
data_block = tmp_len;
|
|
res = rk_hash_update_virt(hash_hdl, tmp_data, tmp_len);
|
|
if (res) {
|
|
rk_hash_final(hash_hdl, NULL);
|
|
printf("rk_hash_update_virt error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
}
|
|
tmp_len -= data_block;
|
|
tmp_data += data_block;
|
|
}
|
|
|
|
rk_hash_final(hash_hdl, output);
|
|
|
|
if (memcmp(output, expected_hash, sizeof(expected_hash)) != 0) {
|
|
printf("HASH result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
printf("Test HASH_VIRT success!\n");
|
|
|
|
exit:
|
|
rk_crypto_deinit();
|
|
return res;
|
|
}
|
|
|
|
RK_RES demo_hmac(void)
|
|
{
|
|
RK_RES res = RK_CRYPTO_ERR_GENERIC;
|
|
rk_hash_config hash_cfg;
|
|
rk_handle hash_hdl = 0;
|
|
uint32_t data_len = sizeof(input);
|
|
rk_crypto_mem *in = NULL;
|
|
uint8_t output[HASH_MAX_LEN];
|
|
|
|
res = rk_crypto_init();
|
|
if (res) {
|
|
printf("rk_crypto_init error! res: 0x%08x\n", res);
|
|
return res;
|
|
}
|
|
|
|
in = rk_crypto_mem_alloc(data_len);
|
|
if (!in) {
|
|
printf("malloc %uByte error!\n", data_len);
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
memcpy(in->vaddr, input, data_len);
|
|
memset(&hash_cfg, 0x00, sizeof(hash_cfg));
|
|
hash_cfg.algo = hmac_algo;
|
|
hash_cfg.key = key;
|
|
hash_cfg.key_len = sizeof(key);
|
|
|
|
res = rk_hash_init(&hash_cfg, &hash_hdl);
|
|
if (res) {
|
|
printf("rk_hash_init error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
res = rk_hash_update(hash_hdl, in->dma_fd, in->size);
|
|
if (res) {
|
|
rk_hash_final(hash_hdl, NULL);
|
|
printf("rk_hash_update error = %d\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
rk_hash_final(hash_hdl, output);
|
|
|
|
/* Verify the result */
|
|
if (memcmp(output, expected_hmac, sizeof(expected_hmac)) != 0) {
|
|
printf("HMAC result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
printf("Test HMAC success!\n");
|
|
|
|
exit:
|
|
rk_crypto_mem_free(in);
|
|
|
|
rk_crypto_deinit();
|
|
|
|
return res;
|
|
}
|
|
|
|
RK_RES demo_hmac_virt(void)
|
|
{
|
|
RK_RES res = RK_CRYPTO_ERR_GENERIC;
|
|
rk_hash_config hash_cfg;
|
|
uint8_t output[HASH_MAX_LEN];
|
|
uint32_t data_len = sizeof(input);
|
|
rk_handle hash_hdl = 0;
|
|
uint32_t data_block = 128;
|
|
uint8_t *tmp_data;
|
|
uint32_t tmp_len;
|
|
|
|
res = rk_crypto_init();
|
|
if (res) {
|
|
printf("rk_crypto_init error! res: 0x%08x\n", res);
|
|
return res;
|
|
}
|
|
|
|
memset(&hash_cfg, 0x00, sizeof(hash_cfg));
|
|
hash_cfg.algo = hmac_algo;
|
|
hash_cfg.key = key;
|
|
hash_cfg.key_len = sizeof(key);
|
|
|
|
res = rk_hash_init(&hash_cfg, &hash_hdl);
|
|
if (res) {
|
|
printf("rk_hash_init error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
tmp_len = data_len;
|
|
tmp_data = input;
|
|
|
|
while (tmp_len) {
|
|
data_block = tmp_len > data_block ? data_block : tmp_len;
|
|
|
|
res = rk_hash_update_virt(hash_hdl, tmp_data, data_block);
|
|
if (res) {
|
|
rk_hash_final(hash_hdl, NULL);
|
|
printf("rk_hash_update_virt error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
tmp_len -= data_block;
|
|
tmp_data += data_block;
|
|
}
|
|
|
|
rk_hash_final(hash_hdl, output);
|
|
|
|
if (memcmp(output, expected_hmac, sizeof(expected_hmac)) != 0) {
|
|
printf("HASH result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
printf("Test HASH_VIRT success!\n");
|
|
|
|
exit:
|
|
rk_crypto_deinit();
|
|
return res;
|
|
}
|