GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)
This commit is contained in:
@@ -0,0 +1,31 @@
|
||||
ifeq ($(CFG_XMEDIA_EXPORT_FLAG),)
|
||||
SDK_DIR := $(shell cd $(CURDIR)/../.. && /bin/pwd)
|
||||
endif
|
||||
|
||||
include $(SDK_DIR)/build/base.mk
|
||||
include $(SAMPLE_DIR)/sample_base.mk
|
||||
|
||||
TARGET := sample_cipher
|
||||
|
||||
LIBS := $(SAMPLE_LIBS) $(SAMPLE_COMMON_LIB)
|
||||
|
||||
INCLUDES := $(SAMPLE_INCLUDES)
|
||||
INCLUDES += -I$(SDK_DIR)/sample/cipher
|
||||
|
||||
CFLAGS := $(SAMPLE_CFLAGS) $(LIBS) $(INCLUDES)
|
||||
|
||||
SRCS := $(wildcard ./*.c)
|
||||
|
||||
OBJS := $(patsubst %.c, %.o, $(SRCS))
|
||||
|
||||
.PHONY: all clean
|
||||
|
||||
all: $(OBJS)
|
||||
$(AT)$(CC) -o $(TARGET) $^ $(CFLAGS)
|
||||
|
||||
%.o : %.c
|
||||
$(AT)$(CC) -c -o $@ $< $(CFLAGS)
|
||||
|
||||
clean:
|
||||
$(AT)rm -rf $(OBJS) $(TARGET)
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
==================
|
||||
Usage descriptions
|
||||
==================
|
||||
1 sample_cipher.c:
|
||||
Show how to use the interfaces for AES encryption and decryption.
|
||||
2 sample_cipher_efuse.c:
|
||||
Show how to use the CA key for AES encryption and decryption.
|
||||
3 sample_cipher_via.c:
|
||||
Show how to use the interfaces of AES that can use virtual address.
|
||||
4 sample_hash.c:
|
||||
Show how to use the interfaces for calclating message of hash.
|
||||
5 sample_multicipher.c:
|
||||
Show how to use the interfaces for multiple blocks encryption and decryption.
|
||||
6 sample_rng.c:
|
||||
Show how to use the interfaces for generating random values.
|
||||
7 sample_rsa_enc.c:
|
||||
Show how to use the interfaces for RSA encryption and decryption.
|
||||
8 sample_rsa_sign.c:
|
||||
Show how to use the interfaces of RSA to sign and verify.
|
||||
@@ -0,0 +1,82 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "sample_api.h"
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_FAILURE;
|
||||
xmedia_u32 func_num = 0;
|
||||
|
||||
if (argc < 2) {
|
||||
printf("\n##########----Run a cipher sample:for example, ./sample 1----###############\n");
|
||||
printf(" You can selset a cipher sample to run as fllow:\n"
|
||||
" [1] CIPHER\n"
|
||||
" [2] CIPHER-MUTILT\n"
|
||||
" [3] CIPHER-EFUSE\n"
|
||||
" [4] HASH\n"
|
||||
" [5] RNG\n"
|
||||
" [6] RSA-SIGN\n"
|
||||
" [7] RSA-ENC\n"
|
||||
" [8] CIPHER-VIA\n");
|
||||
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
func_num = strtol(argv[1], XMEDIA_NULL, 0);
|
||||
|
||||
switch (func_num) {
|
||||
case 1:
|
||||
printf("\n~~~~~~~~~~~~~~~~~~~~~ run sample_cipher ~~~~~~~~~~~~~~~~~~~\n");
|
||||
ret = sample_cipher();
|
||||
break;
|
||||
case 2:
|
||||
printf("\n~~~~~~~~~~~~~~~~~~~~~ run sample_multicipher ~~~~~~~~~~~~~~~~~~~\n");
|
||||
ret = sample_multicipher();
|
||||
break;
|
||||
case 3:
|
||||
printf("\n~~~~~~~~~~~~~~~~~~~~~ run sample_cipher_efuse ~~~~~~~~~~~~~~~~~~~\n");
|
||||
ret = sample_cipher_efuse();
|
||||
break;
|
||||
case 4:
|
||||
printf("\n~~~~~~~~~~~~~~~~~~~~~ run sample_hash ~~~~~~~~~~~~~~~~~~~\n");
|
||||
ret = sample_hash();
|
||||
break;
|
||||
case 5:
|
||||
printf("\n~~~~~~~~~~~~~~~~~~~~~ run sample_rng ~~~~~~~~~~~~~~~~~~~\n");
|
||||
ret = sample_rng();
|
||||
break;
|
||||
case 6:
|
||||
printf("\n~~~~~~~~~~~~~~~~~~~~~ run sample_rsa_sign ~~~~~~~~~~~~~~~~~~~\n");
|
||||
ret = sample_rsa_sign();
|
||||
break;
|
||||
case 7:
|
||||
printf("\n~~~~~~~~~~~~~~~~~~~~~ run sample_rsa_enc ~~~~~~~~~~~~~~~~~~~\n");
|
||||
ret = sample_rsa_enc();
|
||||
break;
|
||||
case 8:
|
||||
printf("\n~~~~~~~~~~~~~~~~~~~~~ run sample_cipher_via ~~~~~~~~~~~~~~~~~~~\n");
|
||||
ret = sample_cipher_via();
|
||||
break;
|
||||
default:
|
||||
printf("Function Number %d do not exist!\n", func_num);
|
||||
ret = XMEDIA_FAILURE;
|
||||
break;
|
||||
}
|
||||
|
||||
if (XMEDIA_SUCCESS == ret) {
|
||||
printf("\n################# FUNCTION %d RUN SUCCESS #################\n", func_num);
|
||||
} else {
|
||||
printf("\n################# FUNCTION %d RUN FAILURE #################\n", func_num);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
#ifndef __SAMPLE_API_H__
|
||||
#define __SAMPLE_API_H__
|
||||
|
||||
#include "xmedia_type.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
xmedia_s32 sample_cipher(xmedia_void);
|
||||
xmedia_s32 sample_cipher_via(xmedia_void);
|
||||
xmedia_s32 sample_multicipher(xmedia_void);
|
||||
xmedia_s32 sample_cipher_efuse(xmedia_void);
|
||||
xmedia_s32 sample_hash(xmedia_void);
|
||||
xmedia_s32 sample_rng(xmedia_void);
|
||||
xmedia_s32 sample_rsa_sign(xmedia_void);
|
||||
xmedia_s32 sample_rsa_enc(xmedia_void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,862 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "xmedia_cipher.h"
|
||||
#include "xmedia_memory.h"
|
||||
#include "sample_common.h"
|
||||
|
||||
#define AES_KEY_MAX_LENGTH 32
|
||||
#define AES128_KEY_LENGTH 16
|
||||
#define AES_IV_LENGTH 16
|
||||
|
||||
static xmedia_s32 set_config_info(xmedia_handle handle, xmedia_bool key_by_ca, xmedia_cipher_alg alg, xmedia_cipher_work_mode mode,
|
||||
xmedia_cipher_key_length key_len, const xmedia_u8 *key, const xmedia_u8 iv[AES_IV_LENGTH])
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_ctrl ctrl;
|
||||
memset(&ctrl, 0, sizeof(xmedia_cipher_ctrl));
|
||||
|
||||
ctrl.alg = alg;
|
||||
ctrl.mode = mode;
|
||||
ctrl.key_by_ca = key_by_ca;
|
||||
|
||||
if (ctrl.alg == XMEDIA_CIPHER_ALG_AES) {
|
||||
/* only support ECB/CBC/CFB/OFB/CTR */
|
||||
if (ctrl.mode <= XMEDIA_CIPHER_WORK_MODE_CTR && ctrl.mode >= XMEDIA_CIPHER_WORK_MODE_ECB) {
|
||||
ctrl.aes_ctrl.bit_width = XMEDIA_CIPHER_BIT_WIDTH_128BIT;
|
||||
ctrl.aes_ctrl.key_len = key_len;
|
||||
ctrl.aes_ctrl.iv_usage = 1;
|
||||
if (ctrl.mode != XMEDIA_CIPHER_WORK_MODE_ECB) {
|
||||
memcpy(ctrl.aes_ctrl.iv, iv, AES_IV_LENGTH);
|
||||
}
|
||||
|
||||
if (key_len == XMEDIA_CIPHER_KEY_AES_128BIT) {
|
||||
memcpy(ctrl.aes_ctrl.key, key, AES128_KEY_LENGTH);
|
||||
} else {
|
||||
memcpy(ctrl.aes_ctrl.key, key, AES_KEY_MAX_LENGTH);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_config_handle(handle, &ctrl);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
static xmedia_s32 ecb_aes256(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 32;
|
||||
xmedia_ulong input_addr_phy = 0;
|
||||
xmedia_ulong output_addr_phy = 0;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[32] = {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
|
||||
0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11};
|
||||
xmedia_u8 aes_src[32] = {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
|
||||
0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11};
|
||||
xmedia_u8 aes_dst[32] = {0x86,0x3a,0xe9,0x1f,0xd4,0xcf,0x51,0x13,0x2d,0xc3,0xe4,0xed,0xf0,0x9d,0xbc,0x6e,
|
||||
0x86,0x3a,0xe9,0x1f,0xd4,0xcf,0x51,0x13,0x2d,0xc3,0xe4,0xed,0xf0,0x9d,0xbc,0x6e};
|
||||
xmedia_u8 aes_iv[16] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
printf("chnid 0x%d\n", chnid);
|
||||
|
||||
input_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufIn", data_len);
|
||||
if (0 == input_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir = xmedia_mmz_map(input_addr_phy, data_len, cached);
|
||||
|
||||
output_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufOut", data_len);
|
||||
if (0 == output_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for output failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir = xmedia_mmz_map(output_addr_phy, data_len, cached);
|
||||
|
||||
// For encrypt
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_ECB,
|
||||
XMEDIA_CIPHER_KEY_AES_256BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("ECB-AES-256-ORI:", aes_src, sizeof(aes_src));
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("ECB-AES-256-ENC:", output_addr_vir, data_len);
|
||||
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher encrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
// For decrypt
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_ECB,
|
||||
XMEDIA_CIPHER_KEY_AES_256BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("ECB-AES-256-DEC:", output_addr_vir, data_len);
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher decrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (input_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir);
|
||||
xmedia_mmz_free(input_addr_phy);
|
||||
}
|
||||
|
||||
if (output_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir);
|
||||
xmedia_mmz_free(output_addr_phy);
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static xmedia_s32 cbc_aes256(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 16;
|
||||
xmedia_ulong input_addr_phy = 0;
|
||||
xmedia_ulong output_addr_phy = 0;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[32] = {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
|
||||
0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11};
|
||||
xmedia_u8 aes_iv[16] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
|
||||
xmedia_u8 aes_src[16] = {0x6B,0xC1,0xBE,0xE2,0x2E,0x40,0x9F,0x96,0xE9,0x3D,0x7E,0x11,0x73,0x93,0x17,0x2A};
|
||||
xmedia_u8 aes_dst[16] = {0xe0,0xfa,0xab,0x42,0xd5,0xa5,0x5c,0x18,0xb0,0x13,0x1f,0x47,0x6c,0xa5,0xd0,0x0a};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
printf("chnid 0x%d\n", chnid);
|
||||
|
||||
input_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufIn", data_len);
|
||||
if (0 == input_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir = xmedia_mmz_map(input_addr_phy, data_len, cached);
|
||||
|
||||
output_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufOut", data_len);
|
||||
if (0 == output_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for output failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir = xmedia_mmz_map(output_addr_phy, data_len, cached);
|
||||
|
||||
// For encrypt
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_256BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("CBC-AES-256-ORI:", aes_src, sizeof(aes_src));
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CBC-AES-256-ENC:", output_addr_vir, sizeof(aes_dst));
|
||||
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher encrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
// For decrypt
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_256BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CBC-AES-256-DEC:", output_addr_vir, data_len);
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher decrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (input_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir);
|
||||
xmedia_mmz_free(input_addr_phy);
|
||||
}
|
||||
|
||||
if (output_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir);
|
||||
xmedia_mmz_free(output_addr_phy);
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static xmedia_s32 cbc_aes192(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 16;
|
||||
xmedia_ulong input_addr_phy = 0;
|
||||
xmedia_ulong output_addr_phy = 0;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[32] = {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
|
||||
0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11};
|
||||
xmedia_u8 aes_iv[16] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
|
||||
xmedia_u8 aes_src[16] = {0x6B,0xC1,0xBE,0xE2,0x2E,0x40,0x9F,0x96,0xE9,0x3D,0x7E,0x11,0x73,0x93,0x17,0x2A};
|
||||
xmedia_u8 aes_dst[16] = {0x69,0x25,0x8f,0xc2,0x8d,0x58,0x8b,0x84,0x67,0x87,0x76,0x02,0x2f,0x9c,0x1c,0x91};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
printf("chnid 0x%d\n", chnid);
|
||||
|
||||
input_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufIn", data_len);
|
||||
if (0 == input_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir = xmedia_mmz_map(input_addr_phy, data_len, cached);
|
||||
|
||||
output_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufOut", data_len);
|
||||
if (0 == output_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for output failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir = xmedia_mmz_map(output_addr_phy, data_len, cached);
|
||||
|
||||
// For encrypt
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_192BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("CBC-AES-192-ORI:", aes_src, sizeof(aes_src));
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CBC-AES-192-ENC:", output_addr_vir, data_len);
|
||||
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher encrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
// For decrypt
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_192BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CBC-AES-192-DEC:", output_addr_vir, data_len);
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher decrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (input_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir);
|
||||
xmedia_mmz_free(input_addr_phy);
|
||||
}
|
||||
|
||||
if (output_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir);
|
||||
xmedia_mmz_free(output_addr_phy);
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static xmedia_s32 cbc_aes128(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 16;
|
||||
xmedia_ulong input_addr_phy = 0;
|
||||
xmedia_ulong output_addr_phy = 0;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[32] = {0x2B,0x7E,0x15,0x16,0x28,0xAE,0xD2,0xA6,0xAB,0xF7,0x15,0x88,0x09,0xCF,0x4F,0x3C};
|
||||
xmedia_u8 aes_iv[16] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
|
||||
xmedia_u8 aes_src[16] = {0x6B,0xC1,0xBE,0xE2,0x2E,0x40,0x9F,0x96,0xE9,0x3D,0x7E,0x11,0x73,0x93,0x17,0x2A};
|
||||
xmedia_u8 aes_dst[16] = {0x76,0x49,0xAB,0xAC,0x81,0x19,0xB2,0x46,0xCE,0xE9,0x8E,0x9B,0x12,0xE9,0x19,0x7D};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
printf("chnid 0x%d\n", chnid);
|
||||
|
||||
input_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufIn", data_len);
|
||||
if (0 == input_addr_phy)
|
||||
{
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir = xmedia_mmz_map(input_addr_phy, data_len, cached);
|
||||
|
||||
output_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufOut", data_len);
|
||||
if (0 == output_addr_phy)
|
||||
{
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for output failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir = xmedia_mmz_map(output_addr_phy, data_len, cached);
|
||||
|
||||
// For encrypt
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("CBC-AES-128-ORI:", aes_src, sizeof(aes_src));
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CBC-AES-128-ENC:", output_addr_vir, sizeof(aes_dst));
|
||||
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher encrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
// For decrypt
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CBC-AES-128-DEC:", output_addr_vir, data_len);
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher decrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (input_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir);
|
||||
xmedia_mmz_free(input_addr_phy);
|
||||
}
|
||||
|
||||
if (output_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir);
|
||||
xmedia_mmz_free(output_addr_phy);
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static xmedia_s32 cfb_aes128(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 32;
|
||||
xmedia_ulong input_addr_phy = 0;
|
||||
xmedia_ulong output_addr_phy = 0;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[32] = {"\x2B\x7E\x15\x16\x28\xAE\xD2\xA6\xAB\xF7\x15\x88\x09\xCF\x4F\x3C"};
|
||||
xmedia_u8 aes_iv[16] = {"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"};
|
||||
xmedia_u8 aes_src[32] = {"\x6B\xC1\xBE\xE2\x2E\x40\x9F\x96\xE9\x3D\x7E\x11\x73\x93\x17\x2A\xAE\x2D\x8A\x57\x1E\x03\xAC\x9C\x9E\xB7\x6F\xAC\x45\xAF\x8E\x51"};
|
||||
xmedia_u8 aes_dst[32] = {"\x3B\x3F\xD9\x2E\xB7\x2D\xAD\x20\x33\x34\x49\xF8\xE8\x3C\xFB\x4A\xC8\xA6\x45\x37\xA0\xB3\xA9\x3F\xCD\xE3\xCD\xAD\x9F\x1C\xE5\x8B"};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
input_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufIn", data_len);
|
||||
if (0 == input_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir = xmedia_mmz_map(input_addr_phy, data_len, cached);
|
||||
output_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufOut", data_len);
|
||||
if (0 == output_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for output failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir = xmedia_mmz_map(output_addr_phy, data_len, cached);
|
||||
|
||||
// For encrypt
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CFB,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("CFB-AES-128-ORI:", aes_src, data_len);
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CFB-AES-128-ENC:", output_addr_vir, data_len);
|
||||
|
||||
//compare
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
// For decrypt
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CFB,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CFB-AES-128-DEC", output_addr_vir, data_len);
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (input_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir);
|
||||
xmedia_mmz_free(input_addr_phy);
|
||||
}
|
||||
|
||||
if (output_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir);
|
||||
xmedia_mmz_free(output_addr_phy);
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static xmedia_s32 ctr_aes128(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 32;
|
||||
xmedia_ulong input_addr_phy = 0;
|
||||
xmedia_ulong output_addr_phy = 0;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[32] = {"\x7E\x24\x06\x78\x17\xFA\xE0\xD7\x43\xD6\xCE\x1F\x32\x53\x91\x63"};
|
||||
xmedia_u8 aes_iv[16] = {"\x00\x6C\xB6\xDB\xC0\x54\x3B\x59\xDA\x48\xD9\x0B\x00\x00\x00\x01"};
|
||||
xmedia_u8 aes_src[32] = {"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"};
|
||||
xmedia_u8 aes_dst[32] = {"\x51\x04\xA1\x06\x16\x8A\x72\xD9\x79\x0D\x41\xEE\x8E\xDA\xD3\x88\xEB\x2E\x1E\xFC\x46\xDA\x57\xC8\xFC\xE6\x30\xDF\x91\x41\xBE\x28"};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
input_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufIn", data_len);
|
||||
if (0 == input_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir = xmedia_mmz_map(input_addr_phy, data_len, cached);
|
||||
output_addr_phy = xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufOut", data_len);
|
||||
if (0 == output_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for outPut failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir = xmedia_mmz_map(output_addr_phy, data_len, cached);
|
||||
|
||||
// For encrypt
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CTR,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("CTR-AES-128-ORI:", aes_src, data_len);
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CTR-AES-128-ENC:", output_addr_vir, data_len);
|
||||
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
// For decrypt
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CTR,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CTR-AES-128-DEC", output_addr_vir, data_len);
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (input_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir);
|
||||
xmedia_mmz_free(input_addr_phy);
|
||||
}
|
||||
|
||||
if (output_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir);
|
||||
xmedia_mmz_free(output_addr_phy);
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int sample_cipher(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
|
||||
ret = ecb_aes256();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = cbc_aes256();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = cbc_aes192();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = cbc_aes128();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = cfb_aes128();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = ctr_aes128();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,345 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/mman.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "xmedia_cipher.h"
|
||||
#include "xmedia_memory.h"
|
||||
#include "sample_common.h"
|
||||
|
||||
#define KEY_IS_ZERO
|
||||
|
||||
#define AES_KEY_MAX_LENGTH 32
|
||||
#define AES128_KEY_LENGTH 16
|
||||
#define AES_IV_LENGTH 16
|
||||
|
||||
static xmedia_u8 aes_128_cbc_key[16] = {0x00,0xe9,0x85,0xde,0x41,0x67,0x6f,0x00,0x96,0x94,0x41,0x54,0x02,0x7d,0xe7,0xc5};
|
||||
#ifdef KEY_IS_ZERO
|
||||
// 使用的AES硬件key（OTP中的key）需要为全0(默认为全0)
|
||||
static xmedia_u8 aes_128_enc_key[16] = {0x00,0x86,0x30,0x1E,0xAF,0x79,0x10,0x06,0x14,0x65,0x6C,0x08,0xE5,0xEE,0x7C,0x19};
|
||||
#else
|
||||
/*
|
||||
* 使用的AES硬件key（OTP中的key）需要为00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff,
|
||||
* 烧写AES硬件key的方法请参考《OTP API参考.docx》
|
||||
*/
|
||||
static xmedia_u8 aes_128_enc_key[16] = {0x53,0x2d,0x81,0x71,0x24,0x3d,0x70,0xcc,0x55,0xad,0x4f,0xb7,0x2a,0x52,0x06,0x8d};
|
||||
#endif
|
||||
static xmedia_u8 aes_128_cbc_IV[16] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
|
||||
static xmedia_u8 aes_128_src_buf[16] = {0x6B,0xC1,0xBE,0xE2,0x2E,0x40,0x9F,0x96,0xE9,0x3D,0x7E,0x11,0x73,0x93,0x17,0x2A};
|
||||
static xmedia_u8 aes_128_dst_buf[16] = {0xF0,0XB7,0X6A,0X0C,0X16,0X06,0XD4,0XDE,0X79,0XCB,0X5C,0X66,0XD3,0X51,0X0C,0XAB};
|
||||
|
||||
static xmedia_s32 set_config(xmedia_handle handle, xmedia_cipher_ca_type type, xmedia_cipher_alg alg, xmedia_cipher_work_mode mode,
|
||||
xmedia_cipher_key_length key_len, const xmedia_u8 *key, const xmedia_u8 iv[AES_IV_LENGTH])
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_ctrl ctrl;
|
||||
memset(&ctrl, 0, sizeof(xmedia_cipher_ctrl));
|
||||
|
||||
ctrl.alg = alg;
|
||||
ctrl.mode = mode;
|
||||
ctrl.key_by_ca = XMEDIA_TRUE;
|
||||
ctrl.ca_type = type;
|
||||
|
||||
if (ctrl.alg == XMEDIA_CIPHER_ALG_AES) {
|
||||
/*only support AES ECB/CBC/CFB/OFB/CTR*/
|
||||
if (ctrl.mode <= XMEDIA_CIPHER_WORK_MODE_CTR && ctrl.mode >= XMEDIA_CIPHER_WORK_MODE_ECB) {
|
||||
ctrl.aes_ctrl.bit_width = XMEDIA_CIPHER_BIT_WIDTH_128BIT;
|
||||
ctrl.aes_ctrl.key_len = key_len;
|
||||
if (ctrl.mode != XMEDIA_CIPHER_WORK_MODE_ECB) {
|
||||
ctrl.aes_ctrl.iv_usage = 1; // must set for CBC , CFB mode
|
||||
memcpy(ctrl.aes_ctrl.iv, iv, AES_IV_LENGTH);
|
||||
}
|
||||
|
||||
if (key_len == XMEDIA_CIPHER_KEY_AES_128BIT) {
|
||||
memcpy(ctrl.aes_ctrl.key, key, AES128_KEY_LENGTH);
|
||||
} else {
|
||||
memcpy(ctrl.aes_ctrl.key, key, AES_KEY_MAX_LENGTH);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_config_handle(handle, &ctrl);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
xmedia_s32 sample_cipher_efuse_vir(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 16;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_cipher_ca_type key_src;
|
||||
xmedia_u8 u8Key[AES128_KEY_LENGTH];
|
||||
xmedia_u8 enc_result[16];
|
||||
xmedia_u8 dec_result[16];
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
memset(u8Key, 0x0, AES128_KEY_LENGTH);
|
||||
|
||||
key_src = XMEDIA_CIPHER_KEY_SRC_KLAD_1;
|
||||
|
||||
ret = xmedia_cipher_klad_encrypt_key(XMEDIA_CIPHER_KEY_SRC_KLAD_1, XMEDIA_CIPHER_KLAD_TARGET_AES, aes_128_cbc_key, u8Key, AES128_KEY_LENGTH);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Error: Klad Encrypt Key failed!\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
if (0 != memcmp(u8Key, aes_128_enc_key, 16)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
print_buffer("clean key", aes_128_cbc_key, 16);
|
||||
print_buffer("encrypt key", u8Key, 16);
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
ret = set_config(chnid,
|
||||
key_src,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
u8Key,
|
||||
aes_128_cbc_IV);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("clear text:", aes_128_src_buf, sizeof(aes_128_src_buf));
|
||||
|
||||
memset(enc_result, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt_vir(chnid, aes_128_src_buf, enc_result, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("encrypted text:", enc_result, data_len);
|
||||
|
||||
/* compare */
|
||||
if (0 != memcmp(enc_result, aes_128_dst_buf, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(dec_result, 0x0, data_len);
|
||||
|
||||
ret = set_config(chnid,
|
||||
key_src,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
u8Key,
|
||||
aes_128_cbc_IV);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("before decrypt:", enc_result, data_len);
|
||||
ret = xmedia_cipher_decrypt_vir(chnid, enc_result, dec_result, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("decrypted text:", dec_result, data_len);
|
||||
/* compare */
|
||||
if (0 != memcmp(dec_result, aes_128_src_buf, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
xmedia_s32 sample_cipher_efuse_phy(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 16;
|
||||
xmedia_u32 input_addr_phy = 0;
|
||||
xmedia_u32 output_addr_phy = 0;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_cipher_ca_type key_src;
|
||||
xmedia_u8 u8Key[AES128_KEY_LENGTH];
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
memset(u8Key, 0x0, AES128_KEY_LENGTH);
|
||||
|
||||
key_src = XMEDIA_CIPHER_KEY_SRC_KLAD_1;
|
||||
|
||||
ret = xmedia_cipher_klad_encrypt_key(XMEDIA_CIPHER_KEY_SRC_KLAD_1, XMEDIA_CIPHER_KLAD_TARGET_AES, aes_128_cbc_key, u8Key, AES128_KEY_LENGTH);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Error: Klad Encrypt Key failed!\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
if (0 != memcmp(u8Key, aes_128_enc_key, 16)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
print_buffer("clean key", aes_128_cbc_key, 16);
|
||||
print_buffer("encrypt key", u8Key, 16);
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
input_addr_phy = (xmedia_u32)xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufIn",data_len);
|
||||
if (0 == input_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir = xmedia_mmz_map(input_addr_phy, data_len, cached);
|
||||
output_addr_phy = (xmedia_u32)xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufOut", data_len);
|
||||
if (0 == output_addr_phy) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for outPut failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir = xmedia_mmz_map(output_addr_phy, data_len, cached);
|
||||
if (0 == output_addr_vir) {
|
||||
ERR_CODE_CIPHER("Errror: Get Viraddr for outPut failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
// For encrypt
|
||||
ret = set_config(chnid,
|
||||
key_src,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
u8Key,
|
||||
aes_128_cbc_IV);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_128_src_buf, data_len);
|
||||
print_buffer("clear text:", aes_128_src_buf, sizeof(aes_128_src_buf));
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("encrypted text:", output_addr_vir, sizeof(aes_128_dst_buf));
|
||||
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_128_dst_buf, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
//For decrypt
|
||||
memcpy(input_addr_vir, aes_128_dst_buf, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config(chnid,
|
||||
key_src,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
u8Key,
|
||||
aes_128_cbc_IV);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("before decrypt:", aes_128_dst_buf, sizeof(aes_128_dst_buf));
|
||||
ret = xmedia_cipher_decrypt(chnid, input_addr_phy, output_addr_phy, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("decrypted text:", output_addr_vir, data_len);
|
||||
// compare
|
||||
if (0 != memcmp(output_addr_vir, aes_128_src_buf, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
if (input_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir);
|
||||
xmedia_mmz_free(input_addr_phy);
|
||||
}
|
||||
|
||||
if (output_addr_phy > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir);
|
||||
xmedia_mmz_free(output_addr_phy);
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int sample_cipher_efuse(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
|
||||
ret = sample_cipher_efuse_vir();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = sample_cipher_efuse_phy();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,450 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "xmedia_cipher.h"
|
||||
#include "sample_common.h"
|
||||
|
||||
#define AES_KEY_MAX_LENGTH 32
|
||||
#define AES128_KEY_LENGTH 16
|
||||
#define AES_IV_LENGTH 16
|
||||
|
||||
static xmedia_s32 set_config_info(xmedia_handle handle, xmedia_bool key_by_ca, xmedia_cipher_alg alg, xmedia_cipher_work_mode mode,
|
||||
xmedia_cipher_key_length key_len, const xmedia_u8 *key, const xmedia_u8 iv[AES_IV_LENGTH])
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_ctrl ctrl;
|
||||
memset(&ctrl, 0, sizeof(xmedia_cipher_ctrl));
|
||||
|
||||
ctrl.alg = alg;
|
||||
ctrl.mode = mode;
|
||||
ctrl.key_by_ca = key_by_ca;
|
||||
|
||||
if (ctrl.alg == XMEDIA_CIPHER_ALG_AES) {
|
||||
/*only support ECB/CBC/CFB/OFB/CTR*/
|
||||
if (ctrl.mode <= XMEDIA_CIPHER_WORK_MODE_CTR && ctrl.mode >= XMEDIA_CIPHER_WORK_MODE_ECB) {
|
||||
ctrl.aes_ctrl.bit_width = XMEDIA_CIPHER_BIT_WIDTH_128BIT;
|
||||
ctrl.aes_ctrl.key_len = key_len;
|
||||
if (ctrl.mode != XMEDIA_CIPHER_WORK_MODE_ECB) {
|
||||
ctrl.aes_ctrl.iv_usage = 1; //must set for CBC , CFB mode
|
||||
memcpy(ctrl.aes_ctrl.iv, iv, AES_IV_LENGTH);
|
||||
}
|
||||
|
||||
if (key_len == XMEDIA_CIPHER_KEY_AES_128BIT) {
|
||||
memcpy(ctrl.aes_ctrl.key, key, AES128_KEY_LENGTH);
|
||||
} else {
|
||||
memcpy(ctrl.aes_ctrl.key, key, AES_KEY_MAX_LENGTH);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_config_handle(handle, &ctrl);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
/* encrypt data using special chn*/
|
||||
static xmedia_s32 cbc_aes128(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 16;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[16] = {0x2B,0x7E,0x15,0x16,0x28,0xAE,0xD2,0xA6,0xAB,0xF7,0x15,0x88,0x09,0xCF,0x4F,0x3C};
|
||||
xmedia_u8 aes_iv[16] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
|
||||
xmedia_u8 aes_src[16] = {0x6B,0xC1,0xBE,0xE2,0x2E,0x40,0x9F,0x96,0xE9,0x3D,0x7E,0x11,0x73,0x93,0x17,0x2A};
|
||||
xmedia_u8 aes_dst[16] = {0x76,0x49,0xAB,0xAC,0x81,0x19,0xB2,0x46,0xCE,0xE9,0x8E,0x9B,0x12,0xE9,0x19,0x7D};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
printf("chnid 0x%d\n", chnid);
|
||||
|
||||
input_addr_vir = (xmedia_u8*)malloc(data_len);
|
||||
if (input_addr_vir == XMEDIA_NULL) {
|
||||
ERR_CODE_CIPHER("malloc input_addr_vir failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
memset(input_addr_vir, 0, data_len);
|
||||
|
||||
output_addr_vir = (xmedia_u8*)malloc(data_len);
|
||||
if (output_addr_vir == XMEDIA_NULL) {
|
||||
ERR_CODE_CIPHER("malloc output_addr_vir failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
memset(output_addr_vir, 0, data_len);
|
||||
|
||||
/* For encrypt */
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("CBC-AES-128-ORI:", aes_src, sizeof(aes_src));
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt_vir(chnid, input_addr_vir, output_addr_vir, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CBC-AES-128-ENC:", output_addr_vir, sizeof(aes_dst));
|
||||
|
||||
/* compare */
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher encrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
/* For decrypt */
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt_vir(chnid, input_addr_vir, output_addr_vir, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CBC-AES-128-DEC:", output_addr_vir, data_len);
|
||||
/* compare */
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("cipher decrypt, memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (XMEDIA_NULL != input_addr_vir) {
|
||||
free(input_addr_vir);
|
||||
input_addr_vir = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != output_addr_vir) {
|
||||
free(output_addr_vir);
|
||||
output_addr_vir = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static xmedia_s32 cfb_aes128(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 32;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[16] = {"\x2B\x7E\x15\x16\x28\xAE\xD2\xA6\xAB\xF7\x15\x88\x09\xCF\x4F\x3C"};
|
||||
xmedia_u8 aes_iv[16] = {"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"};
|
||||
xmedia_u8 aes_src[32] = {"\x6B\xC1\xBE\xE2\x2E\x40\x9F\x96\xE9\x3D\x7E\x11\x73\x93\x17\x2A\xAE\x2D\x8A\x57\x1E\x03\xAC\x9C\x9E\xB7\x6F\xAC\x45\xAF\x8E\x51"};
|
||||
xmedia_u8 aes_dst[32] = {"\x3B\x3F\xD9\x2E\xB7\x2D\xAD\x20\x33\x34\x49\xF8\xE8\x3C\xFB\x4A\xC8\xA6\x45\x37\xA0\xB3\xA9\x3F\xCD\xE3\xCD\xAD\x9F\x1C\xE5\x8B"};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
input_addr_vir = (xmedia_u8*)malloc(data_len);
|
||||
if (input_addr_vir == XMEDIA_NULL) {
|
||||
ERR_CODE_CIPHER("malloc input_addr_vir failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
memset(input_addr_vir, 0, data_len);
|
||||
|
||||
output_addr_vir = (xmedia_u8*)malloc(data_len);
|
||||
if (output_addr_vir == XMEDIA_NULL) {
|
||||
ERR_CODE_CIPHER("malloc output_addr_vir failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
memset(output_addr_vir, 0, data_len);
|
||||
|
||||
/* For encrypt */
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CFB,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memset(input_addr_vir, 0x0, data_len);
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("CFB-AES-128-ORI:", aes_src, data_len);
|
||||
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt_vir(chnid, input_addr_vir, output_addr_vir, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CFB-AES-128-ENC:", output_addr_vir, data_len);
|
||||
|
||||
/* compare */
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
/* For decrypt */
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CFB,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt_vir(chnid, input_addr_vir, output_addr_vir, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CFB-AES-128-DEC", output_addr_vir, data_len);
|
||||
/* compare */
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (XMEDIA_NULL != input_addr_vir) {
|
||||
free(input_addr_vir);
|
||||
input_addr_vir = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != output_addr_vir) {
|
||||
free(output_addr_vir);
|
||||
output_addr_vir = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static xmedia_s32 ctr_aes128(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 32;
|
||||
xmedia_u8 *input_addr_vir = XMEDIA_NULL;
|
||||
xmedia_u8 *output_addr_vir = XMEDIA_NULL;
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_u8 aes_key[16] = {"\x7E\x24\x06\x78\x17\xFA\xE0\xD7\x43\xD6\xCE\x1F\x32\x53\x91\x63"};
|
||||
xmedia_u8 aes_iv[16] = {"\x00\x6C\xB6\xDB\xC0\x54\x3B\x59\xDA\x48\xD9\x0B\x00\x00\x00\x01"};
|
||||
xmedia_u8 aes_src[32] = {"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"};
|
||||
xmedia_u8 aes_dst[32] = {"\x51\x04\xA1\x06\x16\x8A\x72\xD9\x79\x0D\x41\xEE\x8E\xDA\xD3\x88\xEB\x2E\x1E\xFC\x46\xDA\x57\xC8\xFC\xE6\x30\xDF\x91\x41\xBE\x28"};
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
input_addr_vir = (xmedia_u8*)malloc(data_len);
|
||||
if (input_addr_vir == XMEDIA_NULL) {
|
||||
ERR_CODE_CIPHER("malloc input_addr_vir failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
memset(input_addr_vir, 0, data_len);
|
||||
|
||||
output_addr_vir = (xmedia_u8*)malloc(data_len);
|
||||
if (output_addr_vir == XMEDIA_NULL) {
|
||||
ERR_CODE_CIPHER("malloc output_addr_vir failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
memset(output_addr_vir, 0, data_len);
|
||||
|
||||
/* For encrypt */
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CTR,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
memcpy(input_addr_vir, aes_src, data_len);
|
||||
print_buffer("CTR-AES-128-ORI:", aes_src, data_len);
|
||||
|
||||
ret = xmedia_cipher_encrypt_vir(chnid, input_addr_vir, output_addr_vir, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CTR-AES-128-ENC:", output_addr_vir, data_len);
|
||||
|
||||
/* compare */
|
||||
if (0 != memcmp(output_addr_vir, aes_dst, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
/* For decrypt */
|
||||
memcpy(input_addr_vir, aes_dst, data_len);
|
||||
memset(output_addr_vir, 0x0, data_len);
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CTR,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Set config info failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt_vir(chnid, input_addr_vir, output_addr_vir, data_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher decrypt failed.\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("CTR-AES-128-DEC", output_addr_vir, data_len);
|
||||
/* compare */
|
||||
if (0 != memcmp(output_addr_vir, aes_src, data_len)) {
|
||||
ERR_CODE_CIPHER("Memcmp failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
if (XMEDIA_NULL != input_addr_vir) {
|
||||
free(input_addr_vir);
|
||||
input_addr_vir = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != output_addr_vir) {
|
||||
free(output_addr_vir);
|
||||
output_addr_vir = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int sample_cipher_via(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
ret = cbc_aes128();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = cfb_aes128();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = ctr_aes128();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
#ifndef __SAMPLE_COMMON_H__
|
||||
#define __SAMPLE_COMMON_H__
|
||||
|
||||
#include <stdio.h>
|
||||
#include "xmedia_type.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define ERR_CODE_CIPHER(format, arg...) printf( "\033[0;1;31m" format "\033[0m", ## arg)
|
||||
#define INFO_CIPHER(format, arg...) printf( "\033[0;1;32m" format "\033[0m", ## arg)
|
||||
#define TEST_END_PASS() INFO_CIPHER("****************** %s test PASS !!! ******************\n", __FUNCTION__)
|
||||
#define TEST_END_FAIL() ERR_CODE_CIPHER("****************** %s test FAIL !!! ******************\n", __FUNCTION__)
|
||||
#define TEST_RESULT_PRINT() { if (ret) TEST_END_FAIL(); else TEST_END_PASS();}
|
||||
|
||||
static inline xmedia_s32 print_buffer(xmedia_char *string, const xmedia_u8 *input, xmedia_u32 length)
|
||||
{
|
||||
xmedia_u32 i = 0;
|
||||
|
||||
if (XMEDIA_NULL != string) {
|
||||
printf("%s\n", string);
|
||||
}
|
||||
|
||||
for (i = 0 ; i < length; i++) {
|
||||
if ((i % 16 == 0) && (i != 0)) printf("\n");
|
||||
printf("0x%02x ", input[i]);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,486 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/mman.h>
|
||||
#include <linux/fb.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "xmedia_cipher.h"
|
||||
#include "sample_common.h"
|
||||
|
||||
#define MAX_HASH_HANDLE 4
|
||||
#define MAX_HMAC_HANDLE 3
|
||||
|
||||
#define LONG_DATA_SIZE 10000
|
||||
|
||||
static unsigned char sha1_buf[3][128] = {
|
||||
{"abc"},
|
||||
{"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
|
||||
{"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopqabcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"}
|
||||
};
|
||||
static const int sha1_buflen[4] ={3, 56, 112, 1000000};
|
||||
static const unsigned char sha1_sum[5][20] =
|
||||
{
|
||||
{0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E, 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D},
|
||||
{0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE, 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1},
|
||||
{0xaf, 0xc5, 0x3a, 0x4e, 0xa2, 0x08, 0x56, 0xf9, 0x8e, 0x08, 0xdc, 0x6f, 0x3a, 0x5c, 0x98, 0x33, 0x13, 0x77, 0x68, 0xed},
|
||||
{0x34, 0xaa, 0x97, 0x3c, 0xd4, 0xc4, 0xda, 0xa4, 0xf6, 0x1e, 0xeb, 0x2b, 0xdb, 0xad, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6f},
|
||||
{0x7d, 0xf9, 0x62, 0x1f, 0x17, 0xad, 0x18, 0xc5, 0x8a, 0x5a, 0xf7, 0x99, 0x1d, 0x12, 0x62, 0x20, 0x0f, 0xaf, 0xa9, 0x0f}
|
||||
};
|
||||
|
||||
static const unsigned char sha2_sum[4][32] ={
|
||||
/* SHA-256 sample vectors */
|
||||
{0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA, 0x41, 0x41, 0x40, 0xDE, 0x5D, 0xAE, 0x22, 0x23, 0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17, 0x7A, 0x9C, 0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD},
|
||||
{0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8, 0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39, 0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67, 0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1},
|
||||
{0x59, 0xf1, 0x09, 0xd9, 0x53, 0x3b, 0x2b, 0x70, 0xe7, 0xc3, 0xb8, 0x14, 0xa2, 0xbd, 0x21, 0x8f, 0x78, 0xea, 0x5d, 0x37, 0x14, 0x45, 0x5b, 0xc6, 0x79, 0x87, 0xcf, 0x0d, 0x66, 0x43, 0x99 ,0xcf},
|
||||
{0xcd, 0xc7, 0x6e, 0x5c, 0x99, 0x14, 0xfb, 0x92, 0x81, 0xa1, 0xc7, 0xe2, 0x84, 0xd7, 0x3e, 0x67, 0xf1, 0x80, 0x9a, 0x48, 0xa4, 0x97, 0x20, 0x0e, 0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0}
|
||||
};
|
||||
|
||||
static const unsigned char sha224_sum[4][32] ={
|
||||
/* SHA-256 sample vectors */
|
||||
{0x23, 0x09, 0x7d, 0x22, 0x34, 0x05, 0xd8, 0x22, 0x86, 0x42, 0xa4, 0x77, 0xbd, 0xa2, 0x55, 0xb3, 0x2a, 0xad, 0xbc, 0xe4, 0xbd, 0xa0, 0xb3, 0xf7, 0xe3, 0x6c, 0x9d, 0xa7},
|
||||
{0x75, 0x38, 0x8b, 0x16, 0x51, 0x27, 0x76, 0xcc, 0x5d, 0xba, 0x5d, 0xa1, 0xfd, 0x89, 0x01, 0x50, 0xb0, 0xc6, 0x45, 0x5c, 0xb4, 0xf5, 0x8b, 0x19, 0x52, 0x52, 0x25, 0x25},
|
||||
{0x7d, 0xe2, 0xf9, 0x3b, 0x0d, 0x0a, 0x1f, 0x5c, 0xaf, 0x83, 0x77, 0x39, 0xda, 0x74, 0x16, 0x7a, 0x03, 0xbd, 0x64, 0xb7, 0x93, 0x06, 0x7e, 0xbd, 0x40, 0x73, 0xd0, 0xdc},
|
||||
{0x20, 0x79, 0x46, 0x55, 0x98, 0x0c, 0x91, 0xd8, 0xbb, 0xb4, 0xc1, 0xea, 0x97, 0x61, 0x8a, 0x4b, 0xf0, 0x3f, 0x42, 0x58, 0x19, 0x48, 0xb2, 0xee, 0x4e, 0xe7, 0xad, 0x67}
|
||||
};
|
||||
|
||||
static xmedia_u8 sha1_hmac_test_key[3][26] =
|
||||
{
|
||||
{ "This is xx There" },//16 bytes
|
||||
{ "There is the key" },
|
||||
{ "This is your dog" }
|
||||
};
|
||||
|
||||
static xmedia_u8 sha1_hmac_test_sum[3][20] =
|
||||
{
|
||||
{ 0xac, 0xd4, 0x9a, 0xdd, 0x87, 0xba, 0x3b, 0xe2, 0x93, 0xdc, 0x39, 0xc1, 0x72, 0x06, 0xbf, 0xab, 0x8b, 0xde, 0x59, 0xe7 }, // one block
|
||||
{ 0xFC, 0x66, 0xA4, 0xCB, 0x9E, 0xF4, 0xE6, 0x88, 0x19, 0xF3, 0xE9, 0x40, 0xAE, 0xF0, 0x7A, 0x59, 0x5B, 0x72, 0x7A, 0x0F }, // two blocks
|
||||
{ 0x73, 0xD3, 0x86, 0xE3, 0x0E, 0x42, 0x1A, 0x27, 0xC7, 0x53, 0xFA, 0x45, 0xA4, 0x78, 0x31, 0x34, 0xC0, 0x2A, 0x71, 0x2B } // 10000 'a'
|
||||
};
|
||||
|
||||
static xmedia_u8 sha2_hmac_test_sum[3][32] =
|
||||
{
|
||||
{ 0xf1, 0x2b, 0xdb, 0x85, 0xbd, 0x31, 0xaa, 0x46,
|
||||
0x84, 0x3d, 0xca, 0x9b, 0xde, 0x9c, 0xbf, 0x63,
|
||||
0xba, 0x00, 0x55, 0x02, 0x60, 0xdb, 0xbf, 0xc4,
|
||||
0xad, 0x03, 0xc4, 0xdf, 0x98, 0x82, 0x2c, 0x57 }, // one block
|
||||
{ 0xEF, 0x03, 0xC8, 0xB5, 0x2F, 0xFC, 0x02, 0x3B,
|
||||
0x7A, 0x99, 0x69, 0xF7, 0x0E, 0xF6, 0x03, 0x22,
|
||||
0x90, 0x2B, 0x47, 0x98, 0x1F, 0x9B, 0x8F, 0xAF,
|
||||
0xFE, 0x43, 0xE5, 0x61, 0x33, 0x8A, 0xE3, 0x44 }, // two blocks
|
||||
{ 0x4B, 0x3B, 0xF5, 0xA2, 0x57, 0xB6, 0xF9, 0x10,
|
||||
0x35, 0x9E, 0xF4, 0x8D, 0x8A, 0x3B, 0xE1, 0x6E,
|
||||
0x0A, 0x09, 0x3A, 0x96, 0x53, 0x51, 0x72, 0xBD,
|
||||
0x6F, 0x82, 0x0D, 0xBC, 0xFB, 0x1D, 0x9B, 0x00 } // 10000 'a'
|
||||
};
|
||||
|
||||
static xmedia_u8 au8Buf[LONG_DATA_SIZE];
|
||||
|
||||
xmedia_s32 sha1(void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u8 hash[20];
|
||||
xmedia_u32 i = 0,j = 0;
|
||||
xmedia_handle handle[MAX_HASH_HANDLE];
|
||||
xmedia_cipher_hash_attr hash_attr;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
memset(hash, 0, 20);
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
memset(&hash_attr, 0, sizeof(xmedia_cipher_hash_attr));
|
||||
hash_attr.type = XMEDIA_CIPHER_HASH_TYPE_SHA1;
|
||||
|
||||
ret = xmedia_cipher_hash_init(&hash_attr, &handle[i]);
|
||||
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
if (i == 3) {
|
||||
memset(au8Buf, 'a', LONG_DATA_SIZE);
|
||||
for (j=0; j < 1000000 / LONG_DATA_SIZE; j++) {
|
||||
ret = xmedia_cipher_hash_update(handle[i], au8Buf, LONG_DATA_SIZE);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
ret = xmedia_cipher_hash_update(handle[i], sha1_buf[i], sha1_buflen[i]);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
ret = xmedia_cipher_hash_final(handle[i], hash);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
if (memcmp(hash, sha1_sum[i], 20) != 0) {
|
||||
ERR_CODE_CIPHER("sha1 run failed, sample %d!\n", i);
|
||||
print_buffer("Sha1 result:", hash, 20);
|
||||
print_buffer("golden data:", sha1_sum[i], 20);
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
EXIT:
|
||||
|
||||
TEST_RESULT_PRINT();
|
||||
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
xmedia_s32 sha256(void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u8 hash[32];
|
||||
xmedia_u32 i = 0, j = 0;
|
||||
xmedia_handle handle[MAX_HASH_HANDLE];
|
||||
xmedia_cipher_hash_attr hash_attr;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
memset(hash, 0x0, 32);
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
memset(&hash_attr, 0, sizeof(xmedia_cipher_hash_attr));
|
||||
hash_attr.type = XMEDIA_CIPHER_HASH_TYPE_SHA256;
|
||||
|
||||
ret = xmedia_cipher_hash_init(&hash_attr, &handle[i]);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
if (i == 3) {
|
||||
memset(au8Buf, 'a', LONG_DATA_SIZE);
|
||||
for (j=0; j < 1000000 / LONG_DATA_SIZE; j++) {
|
||||
ret = xmedia_cipher_hash_update(handle[i], au8Buf, LONG_DATA_SIZE);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
ret = xmedia_cipher_hash_update(handle[i], sha1_buf[i], sha1_buflen[i]);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
ret = xmedia_cipher_hash_final(handle[i], hash);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
if (memcmp(hash, sha2_sum[i], 32) != 0) {
|
||||
ERR_CODE_CIPHER("sha256 run failed, sample %d!\n", i);
|
||||
print_buffer("Sha256 result:", hash, 32);
|
||||
print_buffer("golden data:", sha2_sum[i], 32);
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
EXIT:
|
||||
|
||||
TEST_RESULT_PRINT();
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
xmedia_s32 sha224(void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u8 hash[28];
|
||||
xmedia_u32 i = 0, j=0;
|
||||
xmedia_handle handle[MAX_HASH_HANDLE];
|
||||
xmedia_cipher_hash_attr hash_attr;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
memset(hash, 0, 28);
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
memset(&hash_attr, 0, sizeof(xmedia_cipher_hash_attr));
|
||||
hash_attr.type = XMEDIA_CIPHER_HASH_TYPE_SHA224;
|
||||
|
||||
ret = xmedia_cipher_hash_init(&hash_attr, &handle[i]);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
if (i == 3) {
|
||||
memset(au8Buf, 'a', LONG_DATA_SIZE);
|
||||
for (j = 0; j < 1000000 / LONG_DATA_SIZE; j++) {
|
||||
ret = xmedia_cipher_hash_update(handle[i], au8Buf, LONG_DATA_SIZE);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
ret = xmedia_cipher_hash_update(handle[i], sha1_buf[i], sha1_buflen[i]);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HASH_HANDLE; i++) {
|
||||
ret = xmedia_cipher_hash_final(handle[i], hash);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
if (memcmp(hash, sha224_sum[i], 28) != 0) {
|
||||
ERR_CODE_CIPHER("sha224 run failed, sample %d!\n", i);
|
||||
print_buffer("Sha224 result:", hash, 28);
|
||||
print_buffer("golden data:", sha224_sum[i], 28);
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
EXIT:
|
||||
|
||||
TEST_RESULT_PRINT();
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
xmedia_s32 hmac_sha1(void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u8 hash[20];
|
||||
xmedia_u32 i = 0;
|
||||
xmedia_handle handle[MAX_HMAC_HANDLE];
|
||||
xmedia_cipher_hash_attr hash_attr;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
memset(&hash_attr, 0, sizeof(xmedia_cipher_hash_attr));
|
||||
hash_attr.hmac_key = malloc(16);
|
||||
hash_attr.hmac_key_len = 16;
|
||||
if (XMEDIA_NULL == hash_attr.hmac_key) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
memset(hash, 0, 20);
|
||||
|
||||
for (i = 0; i < MAX_HMAC_HANDLE; i++) {
|
||||
hash_attr.type = XMEDIA_CIPHER_HASH_TYPE_HMAC_SHA1;
|
||||
memcpy(hash_attr.hmac_key, sha1_hmac_test_key[i], 16);
|
||||
|
||||
ret = xmedia_cipher_hash_init(&hash_attr, &handle[i]);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("hash init failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HMAC_HANDLE; i++) {
|
||||
if (i == 2) {
|
||||
memset(au8Buf, 'a', 10000);
|
||||
ret = xmedia_cipher_hash_update(handle[i], au8Buf, 10000);
|
||||
} else {
|
||||
ret = xmedia_cipher_hash_update(handle[i], sha1_buf[i], sha1_buflen[i]);
|
||||
}
|
||||
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("hash update failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HMAC_HANDLE; i++) {
|
||||
ret = xmedia_cipher_hash_final(handle[i], hash);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("hash final failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
print_buffer("hmac-Sha1 result:", hash, 20);
|
||||
if (memcmp(hash, sha1_hmac_test_sum[i], 20) != 0) {
|
||||
ERR_CODE_CIPHER("\033[0;31m" "hmac_sha1 run failed, sample %d!\n" "\033[0m", i);
|
||||
print_buffer("HMAC1 result:", hash, 20);
|
||||
print_buffer("golden data:", sha1_hmac_test_sum[i], 20);
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
EXIT:
|
||||
|
||||
TEST_RESULT_PRINT();
|
||||
|
||||
free(hash_attr.hmac_key);
|
||||
hash_attr.hmac_key = XMEDIA_NULL;
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
xmedia_s32 hmac_sha256(void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_FAILURE;
|
||||
xmedia_u8 hash[32];
|
||||
xmedia_u32 i = 0;
|
||||
xmedia_handle handle[MAX_HMAC_HANDLE];
|
||||
xmedia_cipher_hash_attr hash_attr;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
memset(hash, 0, 32);
|
||||
|
||||
memset(&hash_attr, 0, sizeof(xmedia_cipher_hash_attr));
|
||||
hash_attr.hmac_key = malloc(16);
|
||||
hash_attr.hmac_key_len = 16;
|
||||
if (XMEDIA_NULL == hash_attr.hmac_key) {
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HMAC_HANDLE; i++) {
|
||||
hash_attr.type = XMEDIA_CIPHER_HASH_TYPE_HMAC_SHA256;
|
||||
memcpy(hash_attr.hmac_key, sha1_hmac_test_key[i], 16);
|
||||
|
||||
ret = xmedia_cipher_hash_init(&hash_attr, &handle[i]);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_HMAC_HANDLE; i++) {
|
||||
if (i == 2) {
|
||||
memset(au8Buf, 'a', 10000);
|
||||
ret = xmedia_cipher_hash_update(handle[i], au8Buf, 10000);
|
||||
} else {
|
||||
ret = xmedia_cipher_hash_update(handle[i], sha1_buf[i], sha1_buflen[i]);
|
||||
}
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
for(i = 0; i < MAX_HMAC_HANDLE; i++) {
|
||||
ret = xmedia_cipher_hash_final(handle[i], hash);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
goto EXIT;
|
||||
}
|
||||
|
||||
print_buffer("hmac-Sha256 result:", hash, 32);
|
||||
if (memcmp(hash, sha2_hmac_test_sum[i], 32) != 0) {
|
||||
ERR_CODE_CIPHER("hmac_sha256 run failed, sample %d!\n", i);
|
||||
print_buffer("HMAC256 result:", hash, 32);
|
||||
print_buffer("golden data:", sha2_hmac_test_sum[i], 20);
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto EXIT;
|
||||
}
|
||||
}
|
||||
|
||||
EXIT:
|
||||
|
||||
TEST_RESULT_PRINT();
|
||||
|
||||
free(hash_attr.hmac_key);
|
||||
hash_attr.hmac_key = XMEDIA_NULL;
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int sample_hash(int argc, char* argv[])
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
|
||||
ret = sha1();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("sha1 run failed!\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = sha256();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("sha256 run failed!\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = hmac_sha1();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("hmac_sha1 run failed!\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = hmac_sha256();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("hmac_sha256 run failed!\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = sha224();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("sha224 run failed!\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,288 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "xmedia_cipher.h"
|
||||
#include "xmedia_memory.h"
|
||||
#include "sample_common.h"
|
||||
|
||||
#define AES_KEY_MAX_LENGTH 32
|
||||
#define AES128_KEY_LENGTH 16
|
||||
#define AES_IV_LENGTH 16
|
||||
|
||||
#define U32_TO_POINT(addr) ((xmedia_void*)((xmedia_ulong)(addr)))
|
||||
#define POINT_TO_U32(addr) ((xmedia_u32)((xmedia_ulong)(addr)))
|
||||
|
||||
static xmedia_u8 aes_key[16] = {0x2B,0x7E,0x15,0x16,0x28,0xAE,0xD2,0xA6,0xAB,0xF7,0x15,0x88,0x09,0xCF,0x4F,0x3C};
|
||||
static xmedia_u8 aes_iv[16] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
|
||||
static xmedia_u8 aes_cbc_enc_src_buf[32] = {0x6B,0xC1,0xBE,0xE2,0x2E,0x40,0x9F,0x96,0xE9,0x3D,0x7E,0x11,0x73,0x93,0x17,0x2A,
|
||||
0x6B,0xC1,0xBE,0xE2,0x2E,0x40,0x9F,0x96,0xE9,0x3D,0x7E,0x11,0x73,0x93,0x17,0x2A};
|
||||
static xmedia_u8 aes_cbc_enc_dst_buf[32] = {0x76,0x49,0xAB,0xAC,0x81,0x19,0xB2,0x46,0xCE,0xE9,0x8E,0x9B,0x12,0xE9,0x19,0x7D,
|
||||
0x4C,0xbb,0xc8,0x58,0x75,0x6b,0x35,0x81,0x25,0x52,0x9e,0x96,0x98,0xa3,0x8f,0x44};
|
||||
static xmedia_u8 aes_cbc_dec_src_buf[16] = {0x76,0x49,0xAB,0xAC,0x81,0x19,0xB2,0x46,0xCE,0xE9,0x8E,0x9B,0x12,0xE9,0x19,0x7D};
|
||||
static xmedia_u8 aes_cbc_dec_dst_buf[16] = {0x6B,0xC1,0xBE,0xE2,0x2E,0x40,0x9F,0x96,0xE9,0x3D,0x7E,0x11,0x73,0x93,0x17,0x2A};
|
||||
|
||||
static xmedia_s32 set_config_info(xmedia_handle handle,
|
||||
xmedia_bool key_by_ca,
|
||||
xmedia_cipher_alg alg,
|
||||
xmedia_cipher_work_mode mode,
|
||||
xmedia_cipher_key_length key_len,
|
||||
const xmedia_u8 *key,
|
||||
const xmedia_u8 iv[AES_IV_LENGTH])
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_ctrl ctrl;
|
||||
memset(&ctrl, 0, sizeof(xmedia_cipher_ctrl));
|
||||
|
||||
ctrl.alg = alg;
|
||||
ctrl.mode = mode;
|
||||
ctrl.key_by_ca = key_by_ca;
|
||||
|
||||
if (ctrl.alg == XMEDIA_CIPHER_ALG_AES) {
|
||||
/* only support ECB/CBC/CFB/OFB/CTR */
|
||||
if (ctrl.mode <= XMEDIA_CIPHER_WORK_MODE_CTR && ctrl.mode >= XMEDIA_CIPHER_WORK_MODE_ECB) {
|
||||
ctrl.aes_ctrl.bit_width = XMEDIA_CIPHER_BIT_WIDTH_128BIT;
|
||||
ctrl.aes_ctrl.key_len = key_len;
|
||||
if (ctrl.mode != XMEDIA_CIPHER_WORK_MODE_ECB) {
|
||||
ctrl.aes_ctrl.iv_usage = CIPHER_IV_CHANGE_ALL_PKG; //must set for CBC , CFB mode
|
||||
memcpy(ctrl.aes_ctrl.iv, iv, AES_IV_LENGTH);
|
||||
}
|
||||
|
||||
if (key_len == XMEDIA_CIPHER_KEY_AES_128BIT) {
|
||||
memcpy(ctrl.aes_ctrl.key, key, AES128_KEY_LENGTH);
|
||||
} else {
|
||||
memcpy(ctrl.aes_ctrl.key, key, AES_KEY_MAX_LENGTH);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_config_handle(handle, &ctrl);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
static xmedia_s32 multicipher_aes_cbc_enc(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 32;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir[3] = {0};
|
||||
xmedia_u8 *output_addr_vir[3] = {0};
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_cipher_package cipher_data_array[3];
|
||||
xmedia_u32 i;
|
||||
|
||||
memset(&cipher_data_array, 0, sizeof(cipher_data_array));
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher init failed.\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher create handle failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
for(i = 0; i < 3; i++) {
|
||||
cipher_data_array[i].src_phy_addr = POINT_TO_U32(xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufIn", data_len));
|
||||
if (0 == cipher_data_array[i].src_phy_addr) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir[i] = xmedia_mmz_map(cipher_data_array[i].src_phy_addr, data_len, cached);
|
||||
|
||||
cipher_data_array[i].dest_phy_addr = POINT_TO_U32(xmedia_mmz_alloc(XMEDIA_NULL, "CIPHER_BufOut", data_len));
|
||||
if (0 == cipher_data_array[i].dest_phy_addr) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for outPut failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir[i] = xmedia_mmz_map(cipher_data_array[i].dest_phy_addr, data_len, cached);
|
||||
|
||||
cipher_data_array[i].byte_length = data_len;
|
||||
memset(input_addr_vir[i], 0x0, data_len);
|
||||
memcpy(input_addr_vir[i], aes_cbc_enc_src_buf, data_len);
|
||||
memset(output_addr_vir[i], 0x0, data_len);
|
||||
}
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher setconfiginfo failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_encrypt_multi(chnid, cipher_data_array, 3);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher encryptMulti failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
print_buffer("GOLD", aes_cbc_enc_dst_buf, data_len);
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
if (0 != memcmp(output_addr_vir[i], aes_cbc_enc_dst_buf, data_len)) {
|
||||
ERR_CODE_CIPHER("MultiCipher AES CBC Encryption run failed on array %d!\n", i);
|
||||
print_buffer("ENC", output_addr_vir[i], data_len);
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
if (cipher_data_array[i].src_phy_addr > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir[i]);
|
||||
xmedia_mmz_free(cipher_data_array[i].src_phy_addr);
|
||||
}
|
||||
|
||||
if (cipher_data_array[i].dest_phy_addr > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir[i]);
|
||||
xmedia_mmz_free(cipher_data_array[i].dest_phy_addr);
|
||||
}
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
static xmedia_s32 multicipher_aes_cbc_dec(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_u32 data_len = 16;
|
||||
xmedia_u32 cached = 0;
|
||||
xmedia_u8 *input_addr_vir[3] = {0};
|
||||
xmedia_u8 *output_addr_vir[3] = {0};
|
||||
xmedia_handle chnid = 0;
|
||||
xmedia_cipher_package cipher_data_array[3];
|
||||
xmedia_u32 i;
|
||||
|
||||
memset(&cipher_data_array, 0, sizeof(cipher_data_array));
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher init failed.\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_create_handle(&chnid);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher Create handle failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
cipher_data_array[i].src_phy_addr = POINT_TO_U32(xmedia_mmz_alloc(XMEDIA_NULL, "cipherIn", data_len));
|
||||
if (0 == cipher_data_array[i].src_phy_addr) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for input failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
input_addr_vir[i] = xmedia_mmz_map(cipher_data_array[i].src_phy_addr, data_len, cached);
|
||||
|
||||
cipher_data_array[i].dest_phy_addr = POINT_TO_U32(xmedia_mmz_alloc(XMEDIA_NULL, "cipherOut", data_len));
|
||||
if (0 == cipher_data_array[i].dest_phy_addr) {
|
||||
ERR_CODE_CIPHER("Error: Get phyaddr for outPut failed!\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
output_addr_vir[i] = xmedia_mmz_map(cipher_data_array[i].dest_phy_addr, data_len, cached);
|
||||
|
||||
cipher_data_array[i].byte_length = data_len;
|
||||
memset(input_addr_vir[i], 0x0, data_len);
|
||||
memcpy(input_addr_vir[i], aes_cbc_dec_src_buf, data_len);
|
||||
memset(output_addr_vir[i], 0x0, data_len);
|
||||
}
|
||||
|
||||
ret = set_config_info(chnid,
|
||||
XMEDIA_FALSE,
|
||||
XMEDIA_CIPHER_ALG_AES,
|
||||
XMEDIA_CIPHER_WORK_MODE_CBC,
|
||||
XMEDIA_CIPHER_KEY_AES_128BIT,
|
||||
aes_key,
|
||||
aes_iv);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher setconfiginfo failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_decrypt_multi(chnid, cipher_data_array, 3);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Cipher DecryptMulti failed.\n");
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
if (0 != memcmp(output_addr_vir[i], aes_cbc_dec_dst_buf, data_len)) {
|
||||
ERR_CODE_CIPHER("MultiCipher AES CBC Decryption run failed on array %d!\n", i);
|
||||
print_buffer("DEC", output_addr_vir[i], data_len);
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto __CIPHER_EXIT__;
|
||||
}
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
__CIPHER_EXIT__:
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
if (cipher_data_array[i].src_phy_addr > 0) {
|
||||
xmedia_mmz_unmap(input_addr_vir[i]);
|
||||
xmedia_mmz_free(cipher_data_array[i].src_phy_addr);
|
||||
}
|
||||
|
||||
if (cipher_data_array[i].dest_phy_addr > 0) {
|
||||
xmedia_mmz_unmap(output_addr_vir[i]);
|
||||
xmedia_mmz_free(cipher_data_array[i].dest_phy_addr);
|
||||
}
|
||||
}
|
||||
|
||||
xmedia_cipher_destroy_handle(chnid);
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int sample_multicipher(xmedia_void)
|
||||
{
|
||||
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
|
||||
ret = multicipher_aes_cbc_enc();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
ERR_CODE_CIPHER("Multi cipher ex aes cbc encrypt failed.\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = multicipher_aes_cbc_dec();
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
ERR_CODE_CIPHER("Multi cipher ex aes cbc decrypt failed.\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "xmedia_cipher.h"
|
||||
#include "sample_common.h"
|
||||
|
||||
int sample_rng(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_s32 index = 0;
|
||||
xmedia_u32 random_number = 0;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_init ERROR!\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
for (index = 0; index < 10; index++) {
|
||||
ret = xmedia_cipher_get_random_number(&random_number);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("There is No ramdom number available now. Try again!\n");
|
||||
index--;
|
||||
continue;
|
||||
}
|
||||
|
||||
printf("Random number: %08x\n", random_number);
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_exit();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_exit error! return value = %d.\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,617 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "xmedia_cipher.h"
|
||||
#include "sample_common.h"
|
||||
|
||||
#define RSA_CRT_SUPPORT
|
||||
|
||||
static unsigned char test_data[] = {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"};
|
||||
unsigned char sha256_sum[32] =
|
||||
{
|
||||
0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8, 0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
|
||||
0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67, 0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1
|
||||
};
|
||||
|
||||
static xmedia_u8 N[] =
|
||||
{
|
||||
0x82, 0x78, 0xA0, 0xC5, 0x39, 0xE6, 0xF6, 0xA1, 0x5E, 0xD1, 0xC6, 0x8B, 0x9C, 0xF9, 0xC4, 0x3F,
|
||||
0xEA, 0x19, 0x16, 0xB0, 0x96, 0x3A, 0xB0, 0x5A, 0x94, 0xED, 0x6A, 0xD3, 0x83, 0xE8, 0xA0, 0xFD,
|
||||
0x01, 0x5E, 0x92, 0x2A, 0x7D, 0x0D, 0xF9, 0x72, 0x1E, 0x03, 0x8A, 0x68, 0x8B, 0x4D, 0x57, 0x55,
|
||||
0xF5, 0x2F, 0x9A, 0xC9, 0x45, 0xCF, 0x9B, 0xB7, 0xF5, 0x11, 0x94, 0x7A, 0x16, 0x0B, 0xED, 0xD9,
|
||||
0xA3, 0xF0, 0x63, 0x8A, 0xEC, 0xD3, 0x21, 0xAB, 0xCF, 0x74, 0xFC, 0x6B, 0xCE, 0x06, 0x4A, 0x51,
|
||||
0xC9, 0x7C, 0x7C, 0xA3, 0xC4, 0x10, 0x63, 0x7B, 0x00, 0xEC, 0x2D, 0x02, 0x18, 0xD5, 0xF1, 0x8E,
|
||||
0x19, 0x7F, 0xBE, 0xE2, 0x45, 0x5E, 0xD7, 0xA8, 0x95, 0x90, 0x88, 0xB0, 0x73, 0x35, 0x89, 0x66,
|
||||
0x1C, 0x23, 0xB9, 0x6E, 0x88, 0xE0, 0x7A, 0x57, 0xB0, 0x55, 0x8B, 0x81, 0x9B, 0x9C, 0x34, 0x9F,
|
||||
0x86, 0x0E, 0x15, 0x94, 0x2C, 0x6B, 0x12, 0xC3, 0xB9, 0x56, 0x60, 0x25, 0x59, 0x3E, 0x50, 0x7B,
|
||||
0x62, 0x4A, 0xD0, 0xF0, 0xB6, 0xB1, 0x94, 0x83, 0x51, 0x66, 0x6F, 0x60, 0x4D, 0xEF, 0x8F, 0x94,
|
||||
0xA6, 0xD1, 0xA2, 0x80, 0x06, 0x24, 0xF2, 0x6E, 0xD2, 0xC7, 0x01, 0x34, 0x8D, 0x2B, 0x6B, 0x03,
|
||||
0xF7, 0x05, 0xA3, 0x99, 0xCC, 0xC5, 0x16, 0x75, 0x1A, 0x81, 0xC1, 0x67, 0xA0, 0x88, 0xE6, 0xE9,
|
||||
0x00, 0xFA, 0x62, 0xAF, 0x2D, 0xA9, 0xFA, 0xC3, 0x30, 0x34, 0x98, 0x05, 0x4C, 0x1A, 0x81, 0x0C,
|
||||
0x52, 0xCE, 0xBA, 0xD6, 0xEB, 0x9C, 0x1E, 0x76, 0x01, 0x41, 0x6C, 0x34, 0xFB, 0xC0, 0x83, 0xC5,
|
||||
0x4E, 0xB3, 0xF2, 0x5B, 0x4F, 0x94, 0x08, 0x33, 0x87, 0x5E, 0xF8, 0x39, 0xEF, 0x7F, 0x72, 0x94,
|
||||
0xFF, 0xD7, 0x51, 0xE8, 0xA2, 0x5E, 0x26, 0x25, 0x5F, 0xE9, 0xCC, 0x2A, 0x7D, 0xAC, 0x5B, 0x35
|
||||
};
|
||||
static xmedia_u8 E[] =
|
||||
{
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01
|
||||
};
|
||||
static xmedia_u8 D[] =
|
||||
{
|
||||
0x49, 0x7E, 0x93, 0xE9, 0xA5, 0x7D, 0x42, 0x0E, 0x92, 0xB0, 0x0E, 0x6C, 0x94, 0xC7, 0x69, 0x52,
|
||||
0x2B, 0x97, 0x68, 0x5D, 0x9E, 0xB2, 0x7E, 0xA6, 0xF7, 0xDF, 0x69, 0x5E, 0xAE, 0x9E, 0x7B, 0x19,
|
||||
0x2A, 0x0D, 0x50, 0xBE, 0xD8, 0x64, 0xE7, 0xCF, 0xED, 0xB2, 0x46, 0xE4, 0x2F, 0x1C, 0x29, 0x07,
|
||||
0x45, 0xAF, 0x44, 0x3C, 0xFE, 0xB3, 0x3C, 0xDF, 0x7A, 0x10, 0x26, 0x18, 0x43, 0x95, 0x02, 0xAD,
|
||||
0xA7, 0x98, 0x81, 0x2A, 0x3F, 0xCF, 0x8A, 0xD7, 0x12, 0x6C, 0xAE, 0xC8, 0x37, 0x6C, 0xF9, 0xAE,
|
||||
0x6A, 0x96, 0x52, 0x4B, 0x99, 0xE5, 0x35, 0x74, 0x93, 0x87, 0x76, 0xAF, 0x08, 0xB8, 0x73, 0x72,
|
||||
0x7D, 0x50, 0xA5, 0x81, 0x26, 0x5C, 0x8F, 0x94, 0xEA, 0x73, 0x59, 0x5C, 0x33, 0xF9, 0xC3, 0x65,
|
||||
0x1E, 0x92, 0xCD, 0x20, 0xC3, 0xBF, 0xD7, 0x8A, 0xCF, 0xCC, 0xD0, 0x61, 0xF8, 0xFB, 0x1B, 0xF4,
|
||||
0xB6, 0x0F, 0xD4, 0xCF, 0x3E, 0x55, 0x48, 0x4C, 0x99, 0x2D, 0x40, 0x44, 0x7C, 0xBA, 0x7B, 0x6F,
|
||||
0xDB, 0x5D, 0x71, 0x91, 0x2D, 0x93, 0x80, 0x19, 0xE3, 0x26, 0x5D, 0x59, 0xBE, 0x46, 0x6D, 0x90,
|
||||
0x4B, 0xDF, 0x72, 0xCE, 0x6C, 0x69, 0x72, 0x8F, 0x5B, 0xA4, 0x74, 0x50, 0x2A, 0x42, 0x95, 0xB2,
|
||||
0x19, 0x04, 0x88, 0xD7, 0xDA, 0xBB, 0x17, 0x23, 0x69, 0xF4, 0x52, 0xEB, 0xC8, 0x55, 0xBE, 0xBC,
|
||||
0x2E, 0xA9, 0xD0, 0x57, 0x7D, 0xC6, 0xC8, 0x8B, 0x86, 0x7B, 0x73, 0xCD, 0xE4, 0x32, 0x79, 0xC0,
|
||||
0x75, 0x53, 0x53, 0xE7, 0x59, 0x38, 0x0A, 0x8C, 0xEC, 0x06, 0xA9, 0xFC, 0xA5, 0x15, 0x81, 0x61,
|
||||
0x3E, 0x44, 0xCD, 0x05, 0xF8, 0x54, 0x04, 0x00, 0x79, 0xB2, 0x0D, 0x69, 0x2A, 0x47, 0x60, 0x1A,
|
||||
0x2B, 0x79, 0x3D, 0x4B, 0x50, 0x8A, 0x31, 0x72, 0x48, 0xBB, 0x75, 0x78, 0xD6, 0x35, 0x90, 0xE1
|
||||
};
|
||||
|
||||
#ifdef RSA_CRT_SUPPORT
|
||||
static xmedia_u8 P[] =
|
||||
{
|
||||
0xC4, 0x29, 0x15, 0xFD, 0xE6, 0xAD, 0x5D, 0x4D, 0xC5, 0xDE, 0x95, 0xB6, 0x4A, 0xA8, 0x25, 0x42,
|
||||
0x15, 0x1D, 0x58, 0x0E, 0xA5, 0xEB, 0xDD, 0xE4, 0xDC, 0x70, 0xA4, 0x28, 0xA7, 0xC1, 0xC9, 0x1C,
|
||||
0xBA, 0x2F, 0xA7, 0xAF, 0xE4, 0xCF, 0xC7, 0xBD, 0x87, 0x3F, 0x7C, 0xD6, 0xD7, 0x7B, 0x7D, 0x4F,
|
||||
0xA1, 0xBB, 0x79, 0x06, 0x2D, 0xF1, 0xDE, 0x00, 0x1E, 0xA9, 0x87, 0x29, 0xFD, 0xE1, 0xA8, 0x43,
|
||||
0xB6, 0x28, 0xC5, 0xF7, 0x2F, 0xFB, 0x64, 0x05, 0x7C, 0x6C, 0xD2, 0xFD, 0x54, 0xE4, 0x43, 0xE0,
|
||||
0x80, 0xD2, 0xE3, 0xE3, 0xB4, 0xBC, 0x4E, 0xE5, 0x59, 0x93, 0x36, 0x5E, 0x9A, 0x79, 0x49, 0x7B,
|
||||
0x40, 0x5F, 0xCE, 0xAE, 0x4A, 0x1B, 0x59, 0x63, 0x5F, 0xA1, 0x37, 0x6C, 0x18, 0x65, 0xA9, 0x2F,
|
||||
0x71, 0x0C, 0x1A, 0xB4, 0xA1, 0x00, 0xD3, 0x20, 0x0D, 0x9A, 0xC1, 0x0B, 0x96, 0x88, 0x16, 0xC9,
|
||||
};
|
||||
static xmedia_u8 Q[] =
|
||||
{
|
||||
0xAA, 0x45, 0x9E, 0x08, 0x44, 0x6B, 0x7B, 0x7D, 0x47, 0x09, 0x4C, 0xFA, 0x24, 0x4A, 0xAD, 0xD3,
|
||||
0x4B, 0xF6, 0x46, 0x35, 0x63, 0xA0, 0xAD, 0xB6, 0x61, 0x0A, 0xE6, 0x1D, 0x8E, 0xAB, 0x74, 0xF1,
|
||||
0x16, 0x5F, 0x83, 0xD8, 0x96, 0xB8, 0x69, 0xC5, 0x17, 0x70, 0x5B, 0x31, 0x18, 0xA4, 0xD7, 0x32,
|
||||
0x83, 0xCD, 0x41, 0xAF, 0xC1, 0xAB, 0xD3, 0xA2, 0x15, 0xBF, 0x29, 0x05, 0x8F, 0xB9, 0xB7, 0xB8,
|
||||
0xDB, 0xCC, 0x42, 0x3C, 0x4E, 0x8C, 0xC7, 0xF2, 0x27, 0x89, 0xA6, 0x0D, 0x6C, 0x4F, 0xD2, 0x11,
|
||||
0x94, 0x64, 0xAA, 0xA0, 0x8C, 0x31, 0x7E, 0x5B, 0x0D, 0xF0, 0x6B, 0xAA, 0xE8, 0x43, 0x80, 0x2B,
|
||||
0x73, 0x1B, 0x69, 0xD0, 0x0F, 0x0F, 0xD8, 0x5E, 0x35, 0xC5, 0xDF, 0x67, 0x86, 0x33, 0x0B, 0xDD,
|
||||
0xE6, 0xCF, 0x6D, 0x2D, 0x60, 0x8B, 0x2B, 0x0F, 0x9F, 0xFA, 0x06, 0x7E, 0x4D, 0x7C, 0x1B, 0x0D,
|
||||
};
|
||||
static xmedia_u8 DP[] =
|
||||
{
|
||||
0x3E, 0xCD, 0x40, 0xA3, 0x37, 0x55, 0x4D, 0xC7, 0xF6, 0x8F, 0x9A, 0xB2, 0xF0, 0x18, 0x01, 0x45,
|
||||
0xB4, 0xE8, 0xDE, 0x26, 0x62, 0x6C, 0xAF, 0x6F, 0xF4, 0x3B, 0x83, 0xF3, 0x18, 0x32, 0x6C, 0xA6,
|
||||
0xEB, 0xDD, 0x11, 0xFC, 0xB8, 0x6E, 0xE5, 0x6E, 0x02, 0x7D, 0x0B, 0x04, 0xE5, 0x9C, 0x3D, 0xB4,
|
||||
0x5E, 0xFD, 0x5C, 0x73, 0xE4, 0x05, 0xC9, 0xA3, 0x94, 0x2D, 0x86, 0x7E, 0xA5, 0x2F, 0xB7, 0xE5,
|
||||
0x65, 0xCE, 0x8C, 0x02, 0xE5, 0xB3, 0xC0, 0x84, 0x19, 0x1F, 0xE6, 0x35, 0x01, 0x16, 0xCB, 0xBC,
|
||||
0x76, 0xC2, 0x0D, 0xFF, 0xFA, 0xFF, 0x46, 0xEB, 0x1A, 0xD0, 0x8C, 0xD9, 0xA0, 0xEF, 0x2F, 0xDD,
|
||||
0x6B, 0xF0, 0xC0, 0x85, 0x00, 0x68, 0xDD, 0x27, 0x79, 0x98, 0x6D, 0xDC, 0x07, 0xBB, 0x94, 0x7D,
|
||||
0x01, 0xDE, 0x74, 0x36, 0x5C, 0x4D, 0x9D, 0x4A, 0x67, 0xD0, 0xA1, 0xF9, 0x89, 0xCA, 0x2C, 0x31,
|
||||
};
|
||||
static xmedia_u8 DQ[] =
|
||||
{
|
||||
0x6F, 0xE5, 0x28, 0x21, 0x4E, 0xB5, 0x43, 0x85, 0xE4, 0x74, 0xDC, 0x3D, 0x56, 0x34, 0x2D, 0x5F,
|
||||
0x3A, 0x00, 0x31, 0xCB, 0x4C, 0x19, 0x7F, 0x8E, 0xE6, 0xDE, 0xFE, 0xB2, 0x55, 0xDB, 0x9F, 0x12,
|
||||
0x00, 0x1D, 0xEC, 0xCB, 0x1C, 0xE1, 0x3B, 0xC0, 0xE5, 0xD2, 0x54, 0x5B, 0x43, 0x52, 0xB0, 0x88,
|
||||
0xE5, 0xCC, 0xB1, 0x6A, 0x0A, 0xE0, 0x1C, 0x47, 0xDB, 0xFA, 0xAF, 0xBE, 0x93, 0xE0, 0xFC, 0x37,
|
||||
0x63, 0x5A, 0x2B, 0xFC, 0xED, 0xB1, 0xDE, 0x83, 0xE8, 0x2F, 0xB1, 0x0C, 0x09, 0x2D, 0xBB, 0x63,
|
||||
0x0A, 0x1D, 0xCD, 0x73, 0x8C, 0x2D, 0xCA, 0x57, 0x94, 0x25, 0x76, 0xDB, 0xED, 0x9E, 0xCE, 0x4F,
|
||||
0xBF, 0x69, 0x38, 0x74, 0x1E, 0x31, 0xCF, 0x82, 0xB9, 0xDB, 0xBB, 0x20, 0x91, 0x34, 0x62, 0x8C,
|
||||
0x04, 0xEE, 0x33, 0x55, 0x2A, 0xA8, 0xCA, 0x37, 0x8E, 0x6E, 0x04, 0x6E, 0x64, 0x05, 0x36, 0xD1,
|
||||
};
|
||||
static xmedia_u8 QP[] =
|
||||
{
|
||||
0xBA, 0xBE, 0x60, 0x75, 0x6A, 0x59, 0x4B, 0x63, 0xE6, 0x2D, 0xBF, 0x48, 0x28, 0xDD, 0xC2, 0x8F,
|
||||
0x3F, 0x59, 0x74, 0xCC, 0xD0, 0xC4, 0x0B, 0xD4, 0x19, 0x2E, 0x88, 0x80, 0x58, 0x8E, 0x28, 0x11,
|
||||
0x69, 0x55, 0xB3, 0xC5, 0x16, 0x12, 0x0F, 0xF5, 0xDB, 0x99, 0x2A, 0xCA, 0x02, 0x1B, 0xA7, 0xBA,
|
||||
0xC0, 0x80, 0x97, 0x63, 0x3A, 0xD7, 0x9F, 0x8C, 0xF4, 0xC7, 0xA8, 0x26, 0xEC, 0x03, 0x36, 0x5C,
|
||||
0xE2, 0x01, 0x07, 0xF4, 0xD6, 0x6E, 0xAF, 0x31, 0x3B, 0x0E, 0xD8, 0xA5, 0x84, 0x9D, 0x8F, 0x20,
|
||||
0x29, 0xA9, 0x28, 0xFB, 0x8D, 0x5D, 0xD4, 0xBD, 0xF0, 0x08, 0x31, 0x88, 0x9E, 0x04, 0x43, 0x5F,
|
||||
0x0F, 0x21, 0x50, 0xBD, 0x25, 0x01, 0xFA, 0xD9, 0x0A, 0xA0, 0xDE, 0xA6, 0x16, 0xDA, 0x11, 0xC3,
|
||||
0x99, 0x05, 0xCA, 0x16, 0x59, 0x62, 0x1F, 0xB4, 0x78, 0xE7, 0x96, 0x1D, 0xCF, 0x2F, 0x23, 0xE8,
|
||||
};
|
||||
#endif
|
||||
|
||||
static xmedia_u8 TYPE_BLOCK_1_RES[] =
|
||||
{
|
||||
0x0d, 0xb7, 0xc4, 0x8e, 0x67, 0xfb, 0x21, 0x1c, 0x05, 0x09, 0xb2, 0x14, 0x1c, 0x60, 0xc5, 0x88,
|
||||
0xf6, 0xb4, 0x2a, 0xf2, 0xe5, 0x69, 0x36, 0xa1, 0xfa, 0x9b, 0xcb, 0xeb, 0x97, 0xee, 0xde, 0xa3,
|
||||
0x58, 0x14, 0xb9, 0x66, 0x68, 0xed, 0x8b, 0x1f, 0xbb, 0xe9, 0x25, 0xfb, 0x5e, 0x7f, 0xd7, 0x5b,
|
||||
0x45, 0xce, 0x0c, 0x44, 0x0b, 0xde, 0x64, 0x3c, 0x43, 0x4d, 0x86, 0x4d, 0x2a, 0x46, 0x7d, 0xc2,
|
||||
0x9b, 0xbe, 0xc6, 0x11, 0x0c, 0x83, 0xa8, 0x40, 0x4d, 0xd2, 0xac, 0x0c, 0xb6, 0x72, 0x5b, 0x63,
|
||||
0x33, 0xb6, 0x2d, 0x56, 0x68, 0x69, 0x61, 0x08, 0xb1, 0xe5, 0x0d, 0x65, 0xca, 0x51, 0x58, 0x1d,
|
||||
0xf3, 0xf9, 0x7e, 0xd9, 0xf3, 0x1f, 0x80, 0xce, 0xf7, 0xcf, 0xcc, 0x9a, 0xe7, 0x85, 0x66, 0x62,
|
||||
0x37, 0x17, 0x30, 0x37, 0xaf, 0x41, 0x70, 0x33, 0xe1, 0x94, 0xa8, 0x9c, 0xf6, 0x0e, 0xb6, 0x6c,
|
||||
0x50, 0x25, 0x46, 0x14, 0xa0, 0xb5, 0x6b, 0x6f, 0xe5, 0x8d, 0x19, 0xc1, 0x76, 0x56, 0x99, 0x96,
|
||||
0x5b, 0x01, 0x38, 0x99, 0x90, 0x79, 0xc9, 0x12, 0xf9, 0x3e, 0xc1, 0xd2, 0x0e, 0xc6, 0xb6, 0xe3,
|
||||
0x3f, 0xbd, 0xf4, 0x57, 0x51, 0xa3, 0x83, 0x15, 0x24, 0xa1, 0x8e, 0xec, 0xaa, 0x1d, 0xb6, 0xcb,
|
||||
0x96, 0xc1, 0xcc, 0x20, 0x93, 0xf3, 0xe1, 0x88, 0x16, 0x8b, 0x2b, 0x37, 0x22, 0xa1, 0x91, 0x34,
|
||||
0xde, 0x40, 0x62, 0x38, 0x20, 0x8f, 0x71, 0x27, 0x8a, 0xdb, 0x47, 0x1c, 0x26, 0xbd, 0x51, 0x51,
|
||||
0x1f, 0x1f, 0xe1, 0xab, 0xbe, 0xfe, 0xfb, 0xbb, 0xd7, 0xea, 0xcc, 0x9b, 0x1e, 0x90, 0x12, 0x36,
|
||||
0xcb, 0xfa, 0x12, 0x4d, 0x01, 0xa6, 0x7f, 0x66, 0x01, 0xe7, 0x71, 0xd7, 0xab, 0xb4, 0xcb, 0x5d,
|
||||
0xf8, 0x62, 0xa4, 0x32, 0xce, 0x1d, 0x6a, 0x96, 0x5e, 0x09, 0x18, 0xdf, 0xa5, 0x7d, 0x33, 0x6f,
|
||||
};
|
||||
|
||||
static xmedia_u8 NO_PADDING[] =
|
||||
{
|
||||
0x31, 0x5d, 0xfa, 0x52, 0xa4, 0x93, 0x52, 0xf8, 0xf5, 0xed, 0x39, 0xf4, 0xf8, 0x23, 0x4b, 0x30,
|
||||
0x11, 0xa2, 0x2c, 0x5b, 0xa9, 0x8c, 0xcf, 0xdf, 0x19, 0x66, 0xf5, 0xf5, 0x1a, 0x6d, 0xf6, 0x25,
|
||||
0x89, 0xaf, 0x06, 0x13, 0xdc, 0xa4, 0xd4, 0x0b, 0x3c, 0x1c, 0x4f, 0xb9, 0xd3, 0xd0, 0x63, 0x29,
|
||||
0x2a, 0x5d, 0xfe, 0xb6, 0x99, 0x20, 0x58, 0x36, 0x2b, 0x1d, 0x57, 0xf4, 0x71, 0x38, 0xa7, 0x8b,
|
||||
0xad, 0x8c, 0xef, 0x1f, 0x2f, 0xea, 0x4c, 0x87, 0x2b, 0xd7, 0xb8, 0xc8, 0xb8, 0x09, 0xcb, 0xb9,
|
||||
0x05, 0xab, 0x43, 0x41, 0xd9, 0x75, 0x36, 0x4d, 0xb6, 0x8a, 0xd3, 0x45, 0x96, 0xfd, 0x9c, 0xe8,
|
||||
0x6e, 0xc8, 0x37, 0x5e, 0x4f, 0x63, 0xf4, 0x1c, 0x18, 0x2c, 0x38, 0x79, 0xe2, 0x5a, 0xe5, 0x1d,
|
||||
0x48, 0xf6, 0xb2, 0x79, 0x57, 0x12, 0xab, 0xae, 0xc1, 0xb1, 0x9d, 0x11, 0x4f, 0xa1, 0x4d, 0x1b,
|
||||
0x4c, 0x8c, 0x3a, 0x2d, 0x7b, 0x98, 0xb9, 0x89, 0x7b, 0x38, 0x84, 0x13, 0x8e, 0x3f, 0x3c, 0xe8,
|
||||
0x59, 0x26, 0x90, 0x77, 0xe7, 0xca, 0x52, 0xbf, 0x3a, 0x5e, 0xe2, 0x58, 0x54, 0xd5, 0x9b, 0x2a,
|
||||
0x0d, 0x33, 0x31, 0xf4, 0x4d, 0x68, 0x68, 0xf3, 0xe9, 0xb2, 0xbe, 0x28, 0xeb, 0xce, 0xdb, 0x36,
|
||||
0x1e, 0xae, 0xb7, 0x37, 0xca, 0xaa, 0xf0, 0x9c, 0x6e, 0x27, 0x93, 0xc9, 0x61, 0x76, 0x99, 0x1a,
|
||||
0x0a, 0x99, 0x57, 0xa8, 0xea, 0x71, 0x96, 0x63, 0xbc, 0x76, 0x11, 0x5c, 0x0c, 0xd4, 0x70, 0x0b,
|
||||
0xd8, 0x1c, 0x4e, 0x95, 0x89, 0x5b, 0x09, 0x17, 0x08, 0x44, 0x70, 0xec, 0x60, 0x7c, 0xc9, 0x8a,
|
||||
0xa0, 0xe8, 0x98, 0x64, 0xfa, 0xe7, 0x52, 0x73, 0xb0, 0x04, 0x9d, 0x78, 0xee, 0x09, 0xa1, 0xb9,
|
||||
0x79, 0xd5, 0x52, 0x4f, 0xf2, 0x39, 0x1c, 0xf7, 0xb9, 0x73, 0xe0, 0x3d, 0x6b, 0x54, 0x64, 0x86
|
||||
};
|
||||
|
||||
static xmedia_s32 pkcs_crt_dec(xmedia_cipher_rsa_enc_scheme scheme, xmedia_u8 *expect)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_rsa_pub_enc rsa_enc;
|
||||
xmedia_cipher_rsa_pri_enc rsa_dec;
|
||||
xmedia_cipher_data input, enc, dec;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("cipher init failed.\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
memset(&rsa_enc, 0, sizeof(xmedia_cipher_rsa_pub_enc));
|
||||
memset(&rsa_dec, 0, sizeof(xmedia_cipher_rsa_pri_enc));
|
||||
|
||||
enc.data = (xmedia_u8 *)malloc(256);
|
||||
if (XMEDIA_NULL == enc.data) {
|
||||
ERR_CODE_CIPHER("malloc for enc failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
dec.data = (xmedia_u8 *)malloc(256);
|
||||
if (XMEDIA_NULL == dec.data) {
|
||||
ERR_CODE_CIPHER("malloc for dec failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
rsa_enc.scheme = scheme;
|
||||
rsa_enc.pub_key.n = N;
|
||||
rsa_enc.pub_key.e = E;
|
||||
rsa_enc.pub_key.n_len = sizeof(N);
|
||||
rsa_enc.pub_key.e_len = sizeof(E);
|
||||
if (scheme == XMEDIA_CIPHER_RSA_ENC_SCHEME_NO_PADDING) {
|
||||
input.data = NO_PADDING;
|
||||
input.data_len = 256;
|
||||
|
||||
ret = xmedia_cipher_rsa_public_encrypt(&rsa_enc, &input, &enc);
|
||||
} else {
|
||||
input.data = test_data;
|
||||
input.data_len = sizeof(test_data) - 1;
|
||||
ret = xmedia_cipher_rsa_public_encrypt(&rsa_enc, &input, &enc);
|
||||
}
|
||||
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_public_encrypt failed\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (expect != XMEDIA_NULL) {
|
||||
if (memcmp(enc.data, expect, enc.data_len) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_public_encrypt error!\n");
|
||||
print_buffer("enc", enc.data, enc.data_len);
|
||||
print_buffer("expect", expect, 256);
|
||||
goto cleanup;
|
||||
}
|
||||
}
|
||||
|
||||
rsa_dec.scheme = scheme;
|
||||
rsa_dec.pri_key.n = N;
|
||||
rsa_dec.pri_key.d = XMEDIA_NULL;
|
||||
rsa_dec.pri_key.p = P;
|
||||
rsa_dec.pri_key.q = Q;
|
||||
rsa_dec.pri_key.dp = DP;
|
||||
rsa_dec.pri_key.dq = DQ;
|
||||
rsa_dec.pri_key.qp = QP;
|
||||
rsa_dec.pri_key.n_len = sizeof(N);
|
||||
rsa_dec.pri_key.d_len = 0;
|
||||
rsa_dec.pri_key.p_len = sizeof(P);
|
||||
rsa_dec.pri_key.q_len = sizeof(Q);
|
||||
rsa_dec.pri_key.dp_len = sizeof(DP);
|
||||
rsa_dec.pri_key.dq_len = sizeof(DQ);
|
||||
rsa_dec.pri_key.qp_len = sizeof(QP);
|
||||
|
||||
ret = xmedia_cipher_rsa_private_decrypt(&rsa_dec, &enc, &dec);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_decrypt failed\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (scheme == XMEDIA_CIPHER_RSA_ENC_SCHEME_NO_PADDING) {
|
||||
if (memcmp(dec.data, NO_PADDING, 256) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_decrypt error!\n");
|
||||
print_buffer("dec", dec.data, dec.data_len);
|
||||
print_buffer("expect", NO_PADDING, 256);
|
||||
goto cleanup;
|
||||
}
|
||||
} else {
|
||||
if ((sizeof(test_data) - 1) != dec.data_len) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_decrypt len error\n");
|
||||
printf("dec: 0x%x, expect: %zu\n", dec.data_len, sizeof(test_data) - 1);
|
||||
goto cleanup;
|
||||
}
|
||||
if (memcmp(dec.data, test_data, sizeof(test_data) - 1) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_decrypt error!\n");
|
||||
|
||||
print_buffer("dec", dec.data, dec.data_len);
|
||||
print_buffer("expect", test_data, sizeof(test_data) - 1);
|
||||
goto cleanup;
|
||||
}
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
xmedia_cipher_exit();
|
||||
|
||||
if (XMEDIA_NULL != enc.data) {
|
||||
free(enc.data);
|
||||
enc.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != dec.data) {
|
||||
free(dec.data);
|
||||
dec.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
|
||||
cleanup:
|
||||
xmedia_cipher_exit();
|
||||
|
||||
if (XMEDIA_NULL != enc.data) {
|
||||
free(enc.data);
|
||||
enc.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != dec.data) {
|
||||
free(dec.data);
|
||||
dec.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
|
||||
static xmedia_s32 pkcs_pub_enc(xmedia_cipher_rsa_enc_scheme scheme, xmedia_u8 *expect)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_rsa_pub_enc rsa_enc;
|
||||
xmedia_cipher_rsa_pri_enc rsa_dec;
|
||||
xmedia_cipher_data input, enc, dec;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("cipher init failed.\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
memset(&rsa_enc, 0, sizeof(xmedia_cipher_rsa_pub_enc));
|
||||
memset(&rsa_dec, 0, sizeof(xmedia_cipher_rsa_pri_enc));
|
||||
|
||||
enc.data = (xmedia_u8 *)malloc(256);
|
||||
if (XMEDIA_NULL == enc.data) {
|
||||
ERR_CODE_CIPHER("malloc for enc failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
dec.data = (xmedia_u8 *)malloc(256);
|
||||
if (XMEDIA_NULL == dec.data) {
|
||||
ERR_CODE_CIPHER("malloc for dec failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
rsa_enc.scheme = scheme;
|
||||
rsa_enc.pub_key.n = N;
|
||||
rsa_enc.pub_key.e = E;
|
||||
rsa_enc.pub_key.n_len = sizeof(N);
|
||||
rsa_enc.pub_key.e_len = sizeof(E);
|
||||
if (scheme == XMEDIA_CIPHER_RSA_ENC_SCHEME_NO_PADDING) {
|
||||
input.data = NO_PADDING;
|
||||
input.data_len = 256;
|
||||
|
||||
ret = xmedia_cipher_rsa_public_encrypt(&rsa_enc, &input, &enc);
|
||||
} else {
|
||||
input.data = test_data;
|
||||
input.data_len = sizeof(test_data) - 1;
|
||||
ret = xmedia_cipher_rsa_public_encrypt(&rsa_enc, &input, &enc);
|
||||
}
|
||||
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_public_encrypt failed\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (expect != XMEDIA_NULL) {
|
||||
if (memcmp(enc.data, expect, enc.data_len) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_public_encrypt error!\n");
|
||||
print_buffer("enc", enc.data, enc.data_len);
|
||||
print_buffer("expect", expect, 256);
|
||||
goto cleanup;
|
||||
}
|
||||
}
|
||||
|
||||
rsa_dec.scheme = scheme;
|
||||
rsa_dec.pri_key.n = N;
|
||||
rsa_dec.pri_key.d = D;
|
||||
rsa_dec.pri_key.n_len = sizeof(N);
|
||||
rsa_dec.pri_key.d_len = sizeof(D);
|
||||
|
||||
ret = xmedia_cipher_rsa_private_decrypt(&rsa_dec, &enc, &dec);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_decrypt failed\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (scheme == XMEDIA_CIPHER_RSA_ENC_SCHEME_NO_PADDING) {
|
||||
if (memcmp(dec.data, NO_PADDING, 256) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_decrypt error!\n");
|
||||
print_buffer("dec", dec.data, dec.data_len);
|
||||
print_buffer("expect", NO_PADDING, 256);
|
||||
goto cleanup;
|
||||
}
|
||||
} else {
|
||||
if ((sizeof(test_data) - 1) != dec.data_len) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_decrypt len error\n");
|
||||
printf("dec: 0x%x, expect: %zu\n", dec.data_len, sizeof(test_data) - 1);
|
||||
goto cleanup;
|
||||
}
|
||||
if (memcmp(dec.data, test_data, sizeof(test_data) - 1) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_decrypt error!\n");
|
||||
|
||||
print_buffer("dec", dec.data, dec.data_len);
|
||||
print_buffer("expect", test_data, sizeof(test_data) - 1);
|
||||
goto cleanup;
|
||||
}
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
xmedia_cipher_exit();
|
||||
|
||||
if (XMEDIA_NULL != enc.data) {
|
||||
free(enc.data);
|
||||
enc.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != dec.data) {
|
||||
free(dec.data);
|
||||
dec.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
|
||||
cleanup:
|
||||
xmedia_cipher_exit();
|
||||
|
||||
if (XMEDIA_NULL != enc.data) {
|
||||
free(enc.data);
|
||||
enc.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != dec.data) {
|
||||
free(dec.data);
|
||||
dec.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
static xmedia_s32 pkcs_pri_enc(xmedia_cipher_rsa_enc_scheme scheme)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_rsa_pri_enc rsa_enc;
|
||||
xmedia_cipher_rsa_pub_enc rsa_dec;
|
||||
xmedia_cipher_data input, enc, dec;
|
||||
xmedia_u8 u8EncD[256];
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
memset(&rsa_enc, 0, sizeof(xmedia_cipher_rsa_pri_enc));
|
||||
memset(&rsa_dec, 0, sizeof(xmedia_cipher_rsa_pub_enc));
|
||||
rsa_enc.scheme = scheme;
|
||||
rsa_dec.scheme = scheme;
|
||||
|
||||
if (scheme == XMEDIA_CIPHER_RSA_ENC_SCHEME_BLOCK_TYPE_1) {
|
||||
rsa_enc.pri_key.n = N;
|
||||
rsa_enc.pri_key.d= u8EncD;
|
||||
rsa_enc.pri_key.n_len = sizeof(N);
|
||||
rsa_enc.pri_key.d_len = sizeof(D);
|
||||
rsa_enc.ca_type = XMEDIA_CIPHER_KEY_SRC_KLAD_1;
|
||||
rsa_dec.pub_key.n = N;
|
||||
rsa_dec.pub_key.e = E;
|
||||
rsa_dec.pub_key.n_len = sizeof(N);
|
||||
rsa_dec.pub_key.e_len = sizeof(E);
|
||||
|
||||
if (rsa_enc.ca_type != XMEDIA_CIPHER_KEY_SRC_USER) {
|
||||
ret = xmedia_cipher_klad_encrypt_key(rsa_enc.ca_type, XMEDIA_CIPHER_KLAD_TARGET_RSA,
|
||||
D, rsa_enc.pri_key.d, rsa_enc.pri_key.d_len);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("Error: Klad Encrypt Key failed!\n");
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
rsa_enc.pri_key.n = N;
|
||||
rsa_enc.pri_key.d = D;
|
||||
rsa_enc.pri_key.n_len = sizeof(N);
|
||||
rsa_enc.pri_key.d_len = sizeof(D);
|
||||
rsa_enc.ca_type = XMEDIA_CIPHER_KEY_SRC_USER;
|
||||
rsa_dec.pub_key.n = N;
|
||||
rsa_dec.pub_key.e = E;
|
||||
rsa_dec.pub_key.n_len = sizeof(N);
|
||||
rsa_dec.pub_key.e_len = sizeof(E);
|
||||
}
|
||||
|
||||
input.data = sha256_sum;
|
||||
input.data_len = sizeof(sha256_sum);
|
||||
|
||||
enc.data = (xmedia_u8 *)malloc(256);
|
||||
if (XMEDIA_NULL == enc.data) {
|
||||
ERR_CODE_CIPHER("malloc for enc.data failed\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_rsa_private_encrypt(&rsa_enc, &input, &enc);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_private_encrypt failed\n");
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
dec.data = (xmedia_u8 *)malloc(32);
|
||||
if (XMEDIA_NULL == enc.data) {
|
||||
ERR_CODE_CIPHER("malloc for dec.data failed\n");
|
||||
ret = XMEDIA_FAILURE;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_rsa_public_decrypt(&rsa_dec, &enc, &dec);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_public_decrypt failed\n");
|
||||
xmedia_cipher_exit();
|
||||
return ret;
|
||||
}
|
||||
|
||||
switch (scheme) {
|
||||
case XMEDIA_CIPHER_RSA_ENC_SCHEME_BLOCK_TYPE_1:
|
||||
if (sizeof(sha256_sum) != dec.data_len) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_public_decrypt len error\n");
|
||||
printf("dec: 0x%x, expect: %zu\n", dec.data_len, sizeof(sha256_sum));
|
||||
goto cleanup;
|
||||
}
|
||||
if (memcmp(dec.data, sha256_sum, dec.data_len) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_public_decrypt error!\n");
|
||||
print_buffer("dec", dec.data, dec.data_len);
|
||||
print_buffer("sha256_sum", sha256_sum, sizeof(sha256_sum));
|
||||
goto cleanup;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
xmedia_cipher_exit();
|
||||
|
||||
if (XMEDIA_NULL != enc.data) {
|
||||
free(enc.data);
|
||||
enc.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != dec.data) {
|
||||
free(dec.data);
|
||||
dec.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
|
||||
cleanup:
|
||||
xmedia_cipher_exit();
|
||||
|
||||
if (XMEDIA_NULL != enc.data) {
|
||||
free(enc.data);
|
||||
enc.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
if (XMEDIA_NULL != dec.data) {
|
||||
free(dec.data);
|
||||
dec.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
int sample_rsa_enc(xmedia_void)
|
||||
{
|
||||
xmedia_s32 s32Ret = XMEDIA_SUCCESS;
|
||||
|
||||
s32Ret = pkcs_crt_dec(XMEDIA_CIPHER_RSA_ENC_SCHEME_NO_PADDING, XMEDIA_NULL);
|
||||
if (s32Ret != XMEDIA_SUCCESS) {
|
||||
return s32Ret;
|
||||
}
|
||||
|
||||
s32Ret = pkcs_pub_enc(XMEDIA_CIPHER_RSA_ENC_SCHEME_NO_PADDING, XMEDIA_NULL);
|
||||
if (s32Ret != XMEDIA_SUCCESS) {
|
||||
return s32Ret;
|
||||
}
|
||||
|
||||
s32Ret = pkcs_pub_enc(XMEDIA_CIPHER_RSA_ENC_SCHEME_BLOCK_TYPE_1, TYPE_BLOCK_1_RES);
|
||||
if (s32Ret != XMEDIA_SUCCESS) {
|
||||
return s32Ret;
|
||||
}
|
||||
|
||||
s32Ret = pkcs_pub_enc(XMEDIA_CIPHER_RSA_ENC_SCHEME_BLOCK_TYPE_2, XMEDIA_NULL);
|
||||
if (s32Ret != XMEDIA_SUCCESS) {
|
||||
return s32Ret;
|
||||
}
|
||||
|
||||
s32Ret = pkcs_pub_enc(XMEDIA_CIPHER_RSA_ENC_SCHEME_RSAES_OAEP_SHA1, XMEDIA_NULL);
|
||||
if (s32Ret != XMEDIA_SUCCESS) {
|
||||
return s32Ret;
|
||||
}
|
||||
|
||||
s32Ret = pkcs_pub_enc(XMEDIA_CIPHER_RSA_ENC_SCHEME_RSAES_OAEP_SHA256, XMEDIA_NULL);
|
||||
if (s32Ret != XMEDIA_SUCCESS) {
|
||||
return s32Ret;
|
||||
}
|
||||
|
||||
s32Ret = pkcs_pub_enc(XMEDIA_CIPHER_RSA_ENC_SCHEME_RSAES_PKCS1_V1_5, XMEDIA_NULL);
|
||||
if (s32Ret != XMEDIA_SUCCESS) {
|
||||
return s32Ret;
|
||||
}
|
||||
|
||||
s32Ret = pkcs_pri_enc(XMEDIA_CIPHER_RSA_ENC_SCHEME_BLOCK_TYPE_1);
|
||||
if (s32Ret != XMEDIA_SUCCESS) {
|
||||
return s32Ret;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
@@ -0,0 +1,370 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "xmedia_type.h"
|
||||
#include "xmedia_cipher.h"
|
||||
#include "sample_common.h"
|
||||
|
||||
#define RSA_CRT_SUPPORT
|
||||
|
||||
static unsigned char test_data[] = {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"};
|
||||
static unsigned char sha256_sum[32] =
|
||||
{
|
||||
0x24, 0x8D, 0x6A, 0x61, 0xD2, 0x06, 0x38, 0xB8, 0xE5, 0xC0, 0x26, 0x93, 0x0C, 0x3E, 0x60, 0x39,
|
||||
0xA3, 0x3C, 0xE4, 0x59, 0x64, 0xFF, 0x21, 0x67, 0xF6, 0xEC, 0xED, 0xD4, 0x19, 0xDB, 0x06, 0xC1
|
||||
};
|
||||
|
||||
static xmedia_u8 N[] =
|
||||
{
|
||||
0x82, 0x78, 0xA0, 0xC5, 0x39, 0xE6, 0xF6, 0xA1, 0x5E, 0xD1, 0xC6, 0x8B, 0x9C, 0xF9, 0xC4, 0x3F,
|
||||
0xEA, 0x19, 0x16, 0xB0, 0x96, 0x3A, 0xB0, 0x5A, 0x94, 0xED, 0x6A, 0xD3, 0x83, 0xE8, 0xA0, 0xFD,
|
||||
0x01, 0x5E, 0x92, 0x2A, 0x7D, 0x0D, 0xF9, 0x72, 0x1E, 0x03, 0x8A, 0x68, 0x8B, 0x4D, 0x57, 0x55,
|
||||
0xF5, 0x2F, 0x9A, 0xC9, 0x45, 0xCF, 0x9B, 0xB7, 0xF5, 0x11, 0x94, 0x7A, 0x16, 0x0B, 0xED, 0xD9,
|
||||
0xA3, 0xF0, 0x63, 0x8A, 0xEC, 0xD3, 0x21, 0xAB, 0xCF, 0x74, 0xFC, 0x6B, 0xCE, 0x06, 0x4A, 0x51,
|
||||
0xC9, 0x7C, 0x7C, 0xA3, 0xC4, 0x10, 0x63, 0x7B, 0x00, 0xEC, 0x2D, 0x02, 0x18, 0xD5, 0xF1, 0x8E,
|
||||
0x19, 0x7F, 0xBE, 0xE2, 0x45, 0x5E, 0xD7, 0xA8, 0x95, 0x90, 0x88, 0xB0, 0x73, 0x35, 0x89, 0x66,
|
||||
0x1C, 0x23, 0xB9, 0x6E, 0x88, 0xE0, 0x7A, 0x57, 0xB0, 0x55, 0x8B, 0x81, 0x9B, 0x9C, 0x34, 0x9F,
|
||||
0x86, 0x0E, 0x15, 0x94, 0x2C, 0x6B, 0x12, 0xC3, 0xB9, 0x56, 0x60, 0x25, 0x59, 0x3E, 0x50, 0x7B,
|
||||
0x62, 0x4A, 0xD0, 0xF0, 0xB6, 0xB1, 0x94, 0x83, 0x51, 0x66, 0x6F, 0x60, 0x4D, 0xEF, 0x8F, 0x94,
|
||||
0xA6, 0xD1, 0xA2, 0x80, 0x06, 0x24, 0xF2, 0x6E, 0xD2, 0xC7, 0x01, 0x34, 0x8D, 0x2B, 0x6B, 0x03,
|
||||
0xF7, 0x05, 0xA3, 0x99, 0xCC, 0xC5, 0x16, 0x75, 0x1A, 0x81, 0xC1, 0x67, 0xA0, 0x88, 0xE6, 0xE9,
|
||||
0x00, 0xFA, 0x62, 0xAF, 0x2D, 0xA9, 0xFA, 0xC3, 0x30, 0x34, 0x98, 0x05, 0x4C, 0x1A, 0x81, 0x0C,
|
||||
0x52, 0xCE, 0xBA, 0xD6, 0xEB, 0x9C, 0x1E, 0x76, 0x01, 0x41, 0x6C, 0x34, 0xFB, 0xC0, 0x83, 0xC5,
|
||||
0x4E, 0xB3, 0xF2, 0x5B, 0x4F, 0x94, 0x08, 0x33, 0x87, 0x5E, 0xF8, 0x39, 0xEF, 0x7F, 0x72, 0x94,
|
||||
0xFF, 0xD7, 0x51, 0xE8, 0xA2, 0x5E, 0x26, 0x25, 0x5F, 0xE9, 0xCC, 0x2A, 0x7D, 0xAC, 0x5B, 0x35
|
||||
};
|
||||
static xmedia_u8 E[] =
|
||||
{
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01
|
||||
};
|
||||
static xmedia_u8 D[] =
|
||||
{
|
||||
0x49, 0x7E, 0x93, 0xE9, 0xA5, 0x7D, 0x42, 0x0E, 0x92, 0xB0, 0x0E, 0x6C, 0x94, 0xC7, 0x69, 0x52,
|
||||
0x2B, 0x97, 0x68, 0x5D, 0x9E, 0xB2, 0x7E, 0xA6, 0xF7, 0xDF, 0x69, 0x5E, 0xAE, 0x9E, 0x7B, 0x19,
|
||||
0x2A, 0x0D, 0x50, 0xBE, 0xD8, 0x64, 0xE7, 0xCF, 0xED, 0xB2, 0x46, 0xE4, 0x2F, 0x1C, 0x29, 0x07,
|
||||
0x45, 0xAF, 0x44, 0x3C, 0xFE, 0xB3, 0x3C, 0xDF, 0x7A, 0x10, 0x26, 0x18, 0x43, 0x95, 0x02, 0xAD,
|
||||
0xA7, 0x98, 0x81, 0x2A, 0x3F, 0xCF, 0x8A, 0xD7, 0x12, 0x6C, 0xAE, 0xC8, 0x37, 0x6C, 0xF9, 0xAE,
|
||||
0x6A, 0x96, 0x52, 0x4B, 0x99, 0xE5, 0x35, 0x74, 0x93, 0x87, 0x76, 0xAF, 0x08, 0xB8, 0x73, 0x72,
|
||||
0x7D, 0x50, 0xA5, 0x81, 0x26, 0x5C, 0x8F, 0x94, 0xEA, 0x73, 0x59, 0x5C, 0x33, 0xF9, 0xC3, 0x65,
|
||||
0x1E, 0x92, 0xCD, 0x20, 0xC3, 0xBF, 0xD7, 0x8A, 0xCF, 0xCC, 0xD0, 0x61, 0xF8, 0xFB, 0x1B, 0xF4,
|
||||
0xB6, 0x0F, 0xD4, 0xCF, 0x3E, 0x55, 0x48, 0x4C, 0x99, 0x2D, 0x40, 0x44, 0x7C, 0xBA, 0x7B, 0x6F,
|
||||
0xDB, 0x5D, 0x71, 0x91, 0x2D, 0x93, 0x80, 0x19, 0xE3, 0x26, 0x5D, 0x59, 0xBE, 0x46, 0x6D, 0x90,
|
||||
0x4B, 0xDF, 0x72, 0xCE, 0x6C, 0x69, 0x72, 0x8F, 0x5B, 0xA4, 0x74, 0x50, 0x2A, 0x42, 0x95, 0xB2,
|
||||
0x19, 0x04, 0x88, 0xD7, 0xDA, 0xBB, 0x17, 0x23, 0x69, 0xF4, 0x52, 0xEB, 0xC8, 0x55, 0xBE, 0xBC,
|
||||
0x2E, 0xA9, 0xD0, 0x57, 0x7D, 0xC6, 0xC8, 0x8B, 0x86, 0x7B, 0x73, 0xCD, 0xE4, 0x32, 0x79, 0xC0,
|
||||
0x75, 0x53, 0x53, 0xE7, 0x59, 0x38, 0x0A, 0x8C, 0xEC, 0x06, 0xA9, 0xFC, 0xA5, 0x15, 0x81, 0x61,
|
||||
0x3E, 0x44, 0xCD, 0x05, 0xF8, 0x54, 0x04, 0x00, 0x79, 0xB2, 0x0D, 0x69, 0x2A, 0x47, 0x60, 0x1A,
|
||||
0x2B, 0x79, 0x3D, 0x4B, 0x50, 0x8A, 0x31, 0x72, 0x48, 0xBB, 0x75, 0x78, 0xD6, 0x35, 0x90, 0xE1
|
||||
};
|
||||
|
||||
#ifdef RSA_CRT_SUPPORT
|
||||
static xmedia_u8 P[] =
|
||||
{
|
||||
0xC4, 0x29, 0x15, 0xFD, 0xE6, 0xAD, 0x5D, 0x4D, 0xC5, 0xDE, 0x95, 0xB6, 0x4A, 0xA8, 0x25, 0x42,
|
||||
0x15, 0x1D, 0x58, 0x0E, 0xA5, 0xEB, 0xDD, 0xE4, 0xDC, 0x70, 0xA4, 0x28, 0xA7, 0xC1, 0xC9, 0x1C,
|
||||
0xBA, 0x2F, 0xA7, 0xAF, 0xE4, 0xCF, 0xC7, 0xBD, 0x87, 0x3F, 0x7C, 0xD6, 0xD7, 0x7B, 0x7D, 0x4F,
|
||||
0xA1, 0xBB, 0x79, 0x06, 0x2D, 0xF1, 0xDE, 0x00, 0x1E, 0xA9, 0x87, 0x29, 0xFD, 0xE1, 0xA8, 0x43,
|
||||
0xB6, 0x28, 0xC5, 0xF7, 0x2F, 0xFB, 0x64, 0x05, 0x7C, 0x6C, 0xD2, 0xFD, 0x54, 0xE4, 0x43, 0xE0,
|
||||
0x80, 0xD2, 0xE3, 0xE3, 0xB4, 0xBC, 0x4E, 0xE5, 0x59, 0x93, 0x36, 0x5E, 0x9A, 0x79, 0x49, 0x7B,
|
||||
0x40, 0x5F, 0xCE, 0xAE, 0x4A, 0x1B, 0x59, 0x63, 0x5F, 0xA1, 0x37, 0x6C, 0x18, 0x65, 0xA9, 0x2F,
|
||||
0x71, 0x0C, 0x1A, 0xB4, 0xA1, 0x00, 0xD3, 0x20, 0x0D, 0x9A, 0xC1, 0x0B, 0x96, 0x88, 0x16, 0xC9,
|
||||
};
|
||||
static xmedia_u8 Q[] =
|
||||
{
|
||||
0xAA, 0x45, 0x9E, 0x08, 0x44, 0x6B, 0x7B, 0x7D, 0x47, 0x09, 0x4C, 0xFA, 0x24, 0x4A, 0xAD, 0xD3,
|
||||
0x4B, 0xF6, 0x46, 0x35, 0x63, 0xA0, 0xAD, 0xB6, 0x61, 0x0A, 0xE6, 0x1D, 0x8E, 0xAB, 0x74, 0xF1,
|
||||
0x16, 0x5F, 0x83, 0xD8, 0x96, 0xB8, 0x69, 0xC5, 0x17, 0x70, 0x5B, 0x31, 0x18, 0xA4, 0xD7, 0x32,
|
||||
0x83, 0xCD, 0x41, 0xAF, 0xC1, 0xAB, 0xD3, 0xA2, 0x15, 0xBF, 0x29, 0x05, 0x8F, 0xB9, 0xB7, 0xB8,
|
||||
0xDB, 0xCC, 0x42, 0x3C, 0x4E, 0x8C, 0xC7, 0xF2, 0x27, 0x89, 0xA6, 0x0D, 0x6C, 0x4F, 0xD2, 0x11,
|
||||
0x94, 0x64, 0xAA, 0xA0, 0x8C, 0x31, 0x7E, 0x5B, 0x0D, 0xF0, 0x6B, 0xAA, 0xE8, 0x43, 0x80, 0x2B,
|
||||
0x73, 0x1B, 0x69, 0xD0, 0x0F, 0x0F, 0xD8, 0x5E, 0x35, 0xC5, 0xDF, 0x67, 0x86, 0x33, 0x0B, 0xDD,
|
||||
0xE6, 0xCF, 0x6D, 0x2D, 0x60, 0x8B, 0x2B, 0x0F, 0x9F, 0xFA, 0x06, 0x7E, 0x4D, 0x7C, 0x1B, 0x0D,
|
||||
};
|
||||
static xmedia_u8 DP[] =
|
||||
{
|
||||
0x3E, 0xCD, 0x40, 0xA3, 0x37, 0x55, 0x4D, 0xC7, 0xF6, 0x8F, 0x9A, 0xB2, 0xF0, 0x18, 0x01, 0x45,
|
||||
0xB4, 0xE8, 0xDE, 0x26, 0x62, 0x6C, 0xAF, 0x6F, 0xF4, 0x3B, 0x83, 0xF3, 0x18, 0x32, 0x6C, 0xA6,
|
||||
0xEB, 0xDD, 0x11, 0xFC, 0xB8, 0x6E, 0xE5, 0x6E, 0x02, 0x7D, 0x0B, 0x04, 0xE5, 0x9C, 0x3D, 0xB4,
|
||||
0x5E, 0xFD, 0x5C, 0x73, 0xE4, 0x05, 0xC9, 0xA3, 0x94, 0x2D, 0x86, 0x7E, 0xA5, 0x2F, 0xB7, 0xE5,
|
||||
0x65, 0xCE, 0x8C, 0x02, 0xE5, 0xB3, 0xC0, 0x84, 0x19, 0x1F, 0xE6, 0x35, 0x01, 0x16, 0xCB, 0xBC,
|
||||
0x76, 0xC2, 0x0D, 0xFF, 0xFA, 0xFF, 0x46, 0xEB, 0x1A, 0xD0, 0x8C, 0xD9, 0xA0, 0xEF, 0x2F, 0xDD,
|
||||
0x6B, 0xF0, 0xC0, 0x85, 0x00, 0x68, 0xDD, 0x27, 0x79, 0x98, 0x6D, 0xDC, 0x07, 0xBB, 0x94, 0x7D,
|
||||
0x01, 0xDE, 0x74, 0x36, 0x5C, 0x4D, 0x9D, 0x4A, 0x67, 0xD0, 0xA1, 0xF9, 0x89, 0xCA, 0x2C, 0x31,
|
||||
};
|
||||
static xmedia_u8 DQ[] =
|
||||
{
|
||||
0x6F, 0xE5, 0x28, 0x21, 0x4E, 0xB5, 0x43, 0x85, 0xE4, 0x74, 0xDC, 0x3D, 0x56, 0x34, 0x2D, 0x5F,
|
||||
0x3A, 0x00, 0x31, 0xCB, 0x4C, 0x19, 0x7F, 0x8E, 0xE6, 0xDE, 0xFE, 0xB2, 0x55, 0xDB, 0x9F, 0x12,
|
||||
0x00, 0x1D, 0xEC, 0xCB, 0x1C, 0xE1, 0x3B, 0xC0, 0xE5, 0xD2, 0x54, 0x5B, 0x43, 0x52, 0xB0, 0x88,
|
||||
0xE5, 0xCC, 0xB1, 0x6A, 0x0A, 0xE0, 0x1C, 0x47, 0xDB, 0xFA, 0xAF, 0xBE, 0x93, 0xE0, 0xFC, 0x37,
|
||||
0x63, 0x5A, 0x2B, 0xFC, 0xED, 0xB1, 0xDE, 0x83, 0xE8, 0x2F, 0xB1, 0x0C, 0x09, 0x2D, 0xBB, 0x63,
|
||||
0x0A, 0x1D, 0xCD, 0x73, 0x8C, 0x2D, 0xCA, 0x57, 0x94, 0x25, 0x76, 0xDB, 0xED, 0x9E, 0xCE, 0x4F,
|
||||
0xBF, 0x69, 0x38, 0x74, 0x1E, 0x31, 0xCF, 0x82, 0xB9, 0xDB, 0xBB, 0x20, 0x91, 0x34, 0x62, 0x8C,
|
||||
0x04, 0xEE, 0x33, 0x55, 0x2A, 0xA8, 0xCA, 0x37, 0x8E, 0x6E, 0x04, 0x6E, 0x64, 0x05, 0x36, 0xD1,
|
||||
};
|
||||
static xmedia_u8 QP[] =
|
||||
{
|
||||
0xBA, 0xBE, 0x60, 0x75, 0x6A, 0x59, 0x4B, 0x63, 0xE6, 0x2D, 0xBF, 0x48, 0x28, 0xDD, 0xC2, 0x8F,
|
||||
0x3F, 0x59, 0x74, 0xCC, 0xD0, 0xC4, 0x0B, 0xD4, 0x19, 0x2E, 0x88, 0x80, 0x58, 0x8E, 0x28, 0x11,
|
||||
0x69, 0x55, 0xB3, 0xC5, 0x16, 0x12, 0x0F, 0xF5, 0xDB, 0x99, 0x2A, 0xCA, 0x02, 0x1B, 0xA7, 0xBA,
|
||||
0xC0, 0x80, 0x97, 0x63, 0x3A, 0xD7, 0x9F, 0x8C, 0xF4, 0xC7, 0xA8, 0x26, 0xEC, 0x03, 0x36, 0x5C,
|
||||
0xE2, 0x01, 0x07, 0xF4, 0xD6, 0x6E, 0xAF, 0x31, 0x3B, 0x0E, 0xD8, 0xA5, 0x84, 0x9D, 0x8F, 0x20,
|
||||
0x29, 0xA9, 0x28, 0xFB, 0x8D, 0x5D, 0xD4, 0xBD, 0xF0, 0x08, 0x31, 0x88, 0x9E, 0x04, 0x43, 0x5F,
|
||||
0x0F, 0x21, 0x50, 0xBD, 0x25, 0x01, 0xFA, 0xD9, 0x0A, 0xA0, 0xDE, 0xA6, 0x16, 0xDA, 0x11, 0xC3,
|
||||
0x99, 0x05, 0xCA, 0x16, 0x59, 0x62, 0x1F, 0xB4, 0x78, 0xE7, 0x96, 0x1D, 0xCF, 0x2F, 0x23, 0xE8,
|
||||
};
|
||||
#endif
|
||||
|
||||
static xmedia_u8 RES[] =
|
||||
{
|
||||
0x5c, 0xfd, 0x7c, 0xb3, 0x9f, 0xf1, 0x2b, 0xd0, 0x73, 0x23, 0x21, 0x4e, 0x25, 0x3d, 0x68, 0x5c,
|
||||
0x6c, 0x4b, 0x12, 0x77, 0x6b, 0x0e, 0x26, 0x80, 0x2a, 0xf4, 0xd2, 0x92, 0x66, 0x40, 0xe0, 0xb2,
|
||||
0x5f, 0xbe, 0x81, 0xa1, 0xda, 0xa4, 0xc5, 0x07, 0x96, 0x17, 0x4a, 0x12, 0x5f, 0xa4, 0x33, 0x43,
|
||||
0x3f, 0x94, 0x7e, 0xe7, 0xbb, 0xd1, 0x7b, 0xde, 0x03, 0xb8, 0xcc, 0xe5, 0x79, 0x5c, 0x3e, 0x5c,
|
||||
0x3c, 0xa1, 0x49, 0xbf, 0xda, 0xc4, 0xb4, 0x73, 0x2d, 0x49, 0x9f, 0x7a, 0xf9, 0x1d, 0x8a, 0xbc,
|
||||
0x39, 0x17, 0xbc, 0xd7, 0x45, 0xaf, 0xad, 0x38, 0x99, 0xc1, 0x1c, 0xf7, 0xe6, 0xf2, 0x7b, 0x16,
|
||||
0x26, 0xaa, 0xa9, 0x16, 0x96, 0xff, 0x02, 0x41, 0x97, 0x1e, 0x81, 0x43, 0xab, 0xff, 0xa8, 0xb7,
|
||||
0x19, 0xdf, 0x19, 0xac, 0x19, 0xdb, 0xbf, 0x15, 0x00, 0x12, 0xbe, 0x64, 0x2b, 0xd4, 0x50, 0x32,
|
||||
0x87, 0xdf, 0x52, 0xb1, 0x78, 0x65, 0x53, 0x7d, 0x10, 0x2d, 0xc1, 0x39, 0xfc, 0x9d, 0x05, 0x15,
|
||||
0x07, 0x84, 0xb2, 0xa1, 0x5b, 0x72, 0x82, 0x22, 0x73, 0x1f, 0x00, 0xbf, 0xf8, 0x71, 0x3a, 0xf3,
|
||||
0x5a, 0x02, 0x60, 0x53, 0x40, 0x44, 0x65, 0x0e, 0xb1, 0x3b, 0xe4, 0x9a, 0xe9, 0x8d, 0x10, 0x81,
|
||||
0xa4, 0x0b, 0xed, 0x02, 0xb7, 0x7f, 0x4a, 0x32, 0x90, 0xbb, 0xe7, 0xe6, 0xb8, 0x69, 0x0f, 0x95,
|
||||
0xea, 0x93, 0x45, 0x2c, 0x5f, 0x76, 0xfd, 0xb6, 0xcb, 0x1a, 0x7b, 0xe9, 0xc1, 0x37, 0xf7, 0x77,
|
||||
0xba, 0xb4, 0x1a, 0x26, 0xea, 0x68, 0x18, 0x35, 0x5d, 0x71, 0xe8, 0x3f, 0xdd, 0x97, 0x7d, 0x57,
|
||||
0xa6, 0x40, 0x45, 0xd8, 0x0d, 0xe4, 0xc7, 0xc0, 0x04, 0xdf, 0x20, 0x9e, 0x3a, 0x85, 0x85, 0x44,
|
||||
0x37, 0x45, 0x31, 0x96, 0x3b, 0xa8, 0xa7, 0xf6, 0xec, 0xff, 0xf1, 0xd1, 0xa4, 0x23, 0x7e, 0x8c
|
||||
};
|
||||
|
||||
static xmedia_s32 rsa_sign_verify(xmedia_cipher_rsa_sign_scheme scheme)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_rsa_sign_attr rsa_sign;
|
||||
xmedia_cipher_rsa_verify_attr rsa_verify;
|
||||
xmedia_cipher_data data, sign;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
memset(&rsa_sign, 0, sizeof(xmedia_cipher_rsa_sign_attr));
|
||||
rsa_sign.scheme = scheme;
|
||||
rsa_sign.pri_key.n = N;
|
||||
rsa_sign.pri_key.d = D;
|
||||
rsa_sign.pri_key.n_len = sizeof(N);
|
||||
rsa_sign.pri_key.d_len = sizeof(D);
|
||||
|
||||
data.data = test_data;
|
||||
data.data_len = sizeof(test_data) - 1;
|
||||
|
||||
sign.data = (xmedia_u8 *)malloc(256);
|
||||
if (XMEDIA_NULL == sign.data) {
|
||||
ERR_CODE_CIPHER("malloc for sign failed\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_rsa_sign(&rsa_sign, &data, sha256_sum, &sign);
|
||||
//ret = xmedia_cipher_rsa_sign(&rsa_sign, &data, XMEDIA_NULL, &sign);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_sign failed\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
switch (scheme) {
|
||||
case XMEDIA_CIPHER_RSA_SIGN_SCHEME_RSASSA_PKCS1_V15_SHA256:
|
||||
if (sizeof(RES) != sign.data_len) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_sign len error\n");
|
||||
printf("sign: 0x%x, expect: %zu\n", sign.data_len, sizeof(RES));
|
||||
goto cleanup;
|
||||
}
|
||||
if (memcmp(sign.data, RES, sizeof(RES)) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_sign failed\n");
|
||||
print_buffer("sign", sign.data, sign.data_len);
|
||||
print_buffer("golden", RES, sizeof(RES));
|
||||
goto cleanup;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
memset(&rsa_verify, 0, sizeof(xmedia_cipher_rsa_verify_attr));
|
||||
rsa_verify.scheme = scheme;
|
||||
rsa_verify.pub_key.n = N;
|
||||
rsa_verify.pub_key.e = E;
|
||||
rsa_verify.pub_key.n_len = sizeof(N);
|
||||
rsa_verify.pub_key.e_len = sizeof(E);
|
||||
|
||||
ret = xmedia_cipher_rsa_verify(&rsa_verify, &data, sha256_sum, &sign);
|
||||
//ret = xmedia_cipher_rsa_verify(&rsa_verify, &data, XMEDIA_NULL, &sign);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_verify failed\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
free(sign.data);
|
||||
sign.data = XMEDIA_NULL;
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
|
||||
cleanup:
|
||||
xmedia_cipher_exit();
|
||||
|
||||
if (XMEDIA_NULL != sign.data) {
|
||||
free(sign.data);
|
||||
sign.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
|
||||
static xmedia_s32 rsa_sign_verify_crt(xmedia_cipher_rsa_sign_scheme scheme)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
xmedia_cipher_rsa_sign_attr rsa_sign;
|
||||
xmedia_cipher_rsa_verify_attr rsa_verify;
|
||||
xmedia_cipher_data data, sign;
|
||||
|
||||
ret = xmedia_cipher_init();
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
memset(&rsa_sign, 0, sizeof(xmedia_cipher_rsa_sign_attr));
|
||||
rsa_sign.scheme = scheme;
|
||||
rsa_sign.pri_key.n = N;
|
||||
rsa_sign.pri_key.d = XMEDIA_NULL;
|
||||
rsa_sign.pri_key.p = P;
|
||||
rsa_sign.pri_key.q = Q;
|
||||
rsa_sign.pri_key.dp = DP;
|
||||
rsa_sign.pri_key.dq = DQ;
|
||||
rsa_sign.pri_key.qp = QP;
|
||||
rsa_sign.pri_key.n_len = sizeof(N);
|
||||
rsa_sign.pri_key.d_len = 0;
|
||||
rsa_sign.pri_key.p_len = sizeof(P);
|
||||
rsa_sign.pri_key.q_len = sizeof(Q);
|
||||
rsa_sign.pri_key.dp_len = sizeof(DP);
|
||||
rsa_sign.pri_key.dq_len = sizeof(DQ);
|
||||
rsa_sign.pri_key.qp_len = sizeof(QP);
|
||||
|
||||
data.data = test_data;
|
||||
data.data_len = sizeof(test_data) - 1;
|
||||
|
||||
sign.data = (xmedia_u8 *)malloc(256);
|
||||
if (XMEDIA_NULL == sign.data) {
|
||||
ERR_CODE_CIPHER("malloc for sign failed\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
ret = xmedia_cipher_rsa_sign(&rsa_sign, &data, sha256_sum, &sign);
|
||||
//ret = xmedia_cipher_rsa_sign(&rsa_sign, &data, XMEDIA_NULL, &sign);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_sign failed\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
switch (scheme) {
|
||||
case XMEDIA_CIPHER_RSA_SIGN_SCHEME_RSASSA_PKCS1_V15_SHA256:
|
||||
if (sizeof(RES) != sign.data_len) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_sign len error\n");
|
||||
printf("sign: 0x%x, expect: %zu\n", sign.data_len, sizeof(RES));
|
||||
goto cleanup;
|
||||
}
|
||||
if (memcmp(sign.data, RES, sizeof(RES)) != 0) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_sign failed\n");
|
||||
print_buffer("sign", sign.data, sign.data_len);
|
||||
print_buffer("golden", RES, sizeof(RES));
|
||||
goto cleanup;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
memset(&rsa_verify, 0, sizeof(xmedia_cipher_rsa_verify_attr));
|
||||
rsa_verify.scheme = scheme;
|
||||
rsa_verify.pub_key.n = N;
|
||||
rsa_verify.pub_key.e = E;
|
||||
rsa_verify.pub_key.n_len = sizeof(N);
|
||||
rsa_verify.pub_key.e_len = sizeof(E);
|
||||
|
||||
ret = xmedia_cipher_rsa_verify(&rsa_verify, &data, sha256_sum, &sign);
|
||||
//ret = xmedia_cipher_rsa_verify(&rsa_verify, &data, XMEDIA_NULL, &sign);
|
||||
if (XMEDIA_SUCCESS != ret) {
|
||||
ERR_CODE_CIPHER("xmedia_cipher_rsa_verify failed\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
free(sign.data);
|
||||
sign.data = XMEDIA_NULL;
|
||||
|
||||
TEST_END_PASS();
|
||||
|
||||
xmedia_cipher_exit();
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
|
||||
cleanup:
|
||||
xmedia_cipher_exit();
|
||||
|
||||
if (XMEDIA_NULL != sign.data) {
|
||||
free(sign.data);
|
||||
sign.data = XMEDIA_NULL;
|
||||
}
|
||||
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
int sample_rsa_sign(xmedia_void)
|
||||
{
|
||||
xmedia_s32 ret = XMEDIA_SUCCESS;
|
||||
|
||||
ret = rsa_sign_verify(XMEDIA_CIPHER_RSA_SIGN_SCHEME_RSASSA_PKCS1_V15_SHA256);
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = rsa_sign_verify(XMEDIA_CIPHER_RSA_SIGN_SCHEME_RSASSA_PKCS1_PSS_SHA256);
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = rsa_sign_verify_crt(XMEDIA_CIPHER_RSA_SIGN_SCHEME_RSASSA_PKCS1_V15_SHA256);
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = rsa_sign_verify_crt(XMEDIA_CIPHER_RSA_SIGN_SCHEME_RSASSA_PKCS1_PSS_SHA256);
|
||||
if (ret != XMEDIA_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user