292 lines
6.8 KiB
C
292 lines
6.8 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"
|
|
|
|
static uint8_t key_0[16] = {
|
|
0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
|
|
0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
|
|
};
|
|
static uint8_t iv[12] = {
|
|
0x10, 0x44, 0x80, 0xb3, 0x88, 0x5f, 0x02, 0x03,
|
|
0x05, 0x21, 0x07, 0xc9,
|
|
};
|
|
static uint8_t aad_in[32] = {
|
|
0x10, 0x44, 0x80, 0xb3, 0x88, 0x5f, 0x02, 0x03,
|
|
0xac, 0x13, 0xfb, 0x23, 0x93, 0x4a, 0x66, 0xe4,
|
|
0x05, 0x21, 0x07, 0xc9, 0x44, 0x00, 0x1b, 0x80,
|
|
0xeb, 0xe7, 0xde, 0x12, 0x8d, 0x77, 0xf4, 0xe8,
|
|
};
|
|
static uint8_t input[32] = {
|
|
0xc9, 0x07, 0x21, 0x05, 0x80, 0x1b, 0x00, 0x44,
|
|
0xac, 0x13, 0xfb, 0x23, 0x93, 0x4a, 0x66, 0xe4,
|
|
0xc9, 0x07, 0x21, 0x05, 0x80, 0x1b, 0x00, 0x44,
|
|
0xac, 0x13, 0xfb, 0x23, 0x93, 0x4a, 0x66, 0xe4,
|
|
};
|
|
static uint8_t expected_enc[32] = {
|
|
0x92, 0x8e, 0xc6, 0x87, 0x7f, 0xca, 0xc7, 0x96,
|
|
0xbf, 0xa7, 0x86, 0xb4, 0xfe, 0xda, 0xf3, 0xec,
|
|
0xdc, 0x24, 0x4d, 0x45, 0x78, 0x3a, 0xe3, 0x3b,
|
|
0x55, 0xbf, 0x9b, 0x9f, 0xbd, 0x4c, 0xf7, 0xe7,
|
|
};
|
|
static uint8_t expected_tag[16] = {
|
|
0x07, 0xf2, 0x31, 0x06, 0xc6, 0xc1, 0x7d, 0x1e,
|
|
0xe7, 0x79, 0xe0, 0x2d, 0x27, 0x5b, 0x5d, 0x12,
|
|
};
|
|
static uint32_t algo = RK_ALGO_AES;
|
|
static uint32_t mode = RK_CIPHER_MODE_GCM;
|
|
|
|
static RK_RES set_ae_config(rk_ae_config *config, uint32_t algo, uint32_t mode, uint32_t operation,
|
|
uint8_t *key, uint32_t key_len, uint8_t *iv, uint32_t iv_len,
|
|
uint32_t tag_len, uint32_t aad_len)
|
|
{
|
|
if (!config || !key || !iv)
|
|
return RK_CRYPTO_ERR_GENERIC;
|
|
|
|
config->algo = algo;
|
|
config->mode = mode;
|
|
config->operation = operation;
|
|
config->key_len = key_len;
|
|
config->iv_len = iv_len;
|
|
config->tag_len = tag_len;
|
|
config->aad_len = aad_len;
|
|
config->reserved = NULL;
|
|
memcpy(config->key, key, key_len);
|
|
memcpy(config->iv, iv, iv_len);
|
|
|
|
return RK_CRYPTO_SUCCESS;
|
|
}
|
|
|
|
RK_RES demo_ae(void)
|
|
{
|
|
RK_RES res = RK_CRYPTO_ERR_GENERIC;
|
|
rk_ae_config config;
|
|
uint32_t data_len = sizeof(input);
|
|
uint32_t aad_len = sizeof(aad_in);
|
|
rk_handle handle = 0;
|
|
rk_crypto_mem *in = NULL;
|
|
rk_crypto_mem *out = NULL;
|
|
rk_crypto_mem *aad = NULL;
|
|
uint8_t tag[16];
|
|
|
|
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;
|
|
}
|
|
|
|
out = rk_crypto_mem_alloc(data_len);
|
|
if (!out) {
|
|
printf("malloc %uByte error!\n", data_len);
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
aad = rk_crypto_mem_alloc(aad_len);
|
|
if (!aad) {
|
|
printf("malloc %uByte error!\n", aad_len);
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
res = set_ae_config(&config, algo, mode, RK_OP_CIPHER_ENC, key_0, sizeof(key_0), iv,
|
|
sizeof(iv), sizeof(expected_tag), aad_len);
|
|
if (res) {
|
|
printf("set_ae_config error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
memcpy(in->vaddr, input, data_len);
|
|
memcpy(aad->vaddr, aad_in, aad_len);
|
|
memset(tag, 0, sizeof(tag));
|
|
|
|
res = rk_ae_init(&config, &handle);
|
|
if (res) {
|
|
printf("rk_ae_init error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
res = rk_ae_set_aad(handle, aad->dma_fd);
|
|
if (res) {
|
|
printf("rk_ae_set_aad error! res: 0x%08x\n", res);
|
|
rk_ae_final(handle);
|
|
goto exit;
|
|
}
|
|
|
|
res = rk_ae_crypt(handle, in->dma_fd, out->dma_fd, data_len, tag);
|
|
if (res) {
|
|
printf("rk_ae_crypt error! res: 0x%08x\n", res);
|
|
rk_ae_final(handle);
|
|
goto exit;
|
|
}
|
|
|
|
rk_ae_final(handle);
|
|
|
|
if (memcmp(out->vaddr, expected_enc, data_len)) {
|
|
printf("ENC result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
if (memcmp(tag, expected_tag, sizeof(expected_tag))) {
|
|
printf("ENC tag not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
printf("Test AE ENC success!\n");
|
|
|
|
config.operation = RK_OP_CIPHER_DEC;
|
|
memcpy(config.iv, iv, sizeof(iv));
|
|
|
|
res = rk_ae_init(&config, &handle);
|
|
if (res) {
|
|
printf("rk_ae_init error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
res = rk_ae_set_aad(handle, aad->dma_fd);
|
|
if (res) {
|
|
printf("rk_ae_set_aad error! res: 0x%08x\n", res);
|
|
rk_ae_final(handle);
|
|
goto exit;
|
|
}
|
|
|
|
/* Ensure the the tag is correct, it will be checked when decrypting */
|
|
res = rk_ae_crypt(handle, out->dma_fd, out->dma_fd, data_len, tag);
|
|
if (res) {
|
|
printf("rk_ae_crypt error! res: 0x%08x\n", res);
|
|
rk_ae_final(handle);
|
|
goto exit;
|
|
}
|
|
|
|
rk_ae_final(handle);
|
|
|
|
if (memcmp(out->vaddr, input, data_len)) {
|
|
printf("DEC result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
printf("Test AE DEC success!\n");
|
|
|
|
exit:
|
|
rk_crypto_mem_free(in);
|
|
rk_crypto_mem_free(out);
|
|
rk_crypto_mem_free(aad);
|
|
|
|
rk_crypto_deinit();
|
|
|
|
return res;
|
|
}
|
|
|
|
RK_RES demo_ae_virt(void)
|
|
{
|
|
RK_RES res = RK_CRYPTO_ERR_GENERIC;
|
|
rk_ae_config config;
|
|
uint32_t data_len = sizeof(input);
|
|
uint8_t output[32];
|
|
uint8_t tag[16];
|
|
rk_handle handle = 0;
|
|
|
|
res = rk_crypto_init();
|
|
if (res) {
|
|
printf("rk_crypto_init error! res: 0x%08x\n", res);
|
|
return res;
|
|
}
|
|
|
|
res = set_ae_config(&config, algo, mode, RK_OP_CIPHER_ENC, key_0, sizeof(key_0), iv,
|
|
sizeof(iv), sizeof(expected_tag), sizeof(aad_in));
|
|
if (res) {
|
|
printf("set_ae_config error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
memset(tag, 0, sizeof(tag));
|
|
|
|
res = rk_ae_init(&config, &handle);
|
|
if (res) {
|
|
printf("rk_ae_init error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
res = rk_ae_set_aad_virt(handle, aad_in);
|
|
if (res) {
|
|
printf("rk_ae_set_aad error! res: 0x%08x\n", res);
|
|
rk_ae_final(handle);
|
|
goto exit;
|
|
}
|
|
|
|
res = rk_ae_crypt_virt(handle, input, output, data_len, tag);
|
|
if (res) {
|
|
rk_ae_final(handle);
|
|
printf("rk_ae_crypt_virt error[%x]\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
rk_ae_final(handle);
|
|
|
|
if (memcmp(output, expected_enc, data_len)) {
|
|
printf("ENC result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
if (memcmp(tag, expected_tag, sizeof(expected_tag))) {
|
|
printf("ENC result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
printf("Test AE_VIRT ENC success!\n");
|
|
|
|
config.operation = RK_OP_CIPHER_DEC;
|
|
memcpy(config.iv, iv, sizeof(iv));
|
|
|
|
res = rk_ae_init(&config, &handle);
|
|
if (res) {
|
|
printf("rk_ae_init error! res: 0x%08x\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
res = rk_ae_set_aad_virt(handle, aad_in);
|
|
if (res) {
|
|
printf("rk_ae_set_aad error! res: 0x%08x\n", res);
|
|
rk_ae_final(handle);
|
|
goto exit;
|
|
}
|
|
|
|
/* Ensure the the tag is correct, it will be checked when decrypting */
|
|
res = rk_ae_crypt_virt(handle, output, output, data_len, tag);
|
|
if (res) {
|
|
rk_ae_final(handle);
|
|
printf("rk_ae_crypt_virt error[%x]\n", res);
|
|
goto exit;
|
|
}
|
|
|
|
rk_ae_final(handle);
|
|
|
|
if (memcmp(output, input, data_len)) {
|
|
printf("DEC result not equal to expected value, error!\n");
|
|
res = RK_CRYPTO_ERR_GENERIC;
|
|
goto exit;
|
|
}
|
|
|
|
printf("Test AE_VIRT DEC success!\n");
|
|
|
|
exit:
|
|
rk_crypto_deinit();
|
|
return res;
|
|
}
|