Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
OpenHarmony
Xts Acts
提交
d527b885
X
Xts Acts
项目概览
OpenHarmony
/
Xts Acts
大约 1 年 前同步成功
通知
9
Star
22
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
X
Xts Acts
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
d527b885
编写于
10月 24, 2022
作者:
Q
qiaozzzh
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
deviceauth代码整改
Signed-off-by:
N
qiaozzzh
<
qiaozhang@huawei.com
>
上级
4ecb7b3b
变更
33
显示空白变更内容
内联
并排
Showing
33 changed file
with
0 addition
and
5220 deletion
+0
-5220
security_lite/deviceauth_basic_deps/BUILD.gn
security_lite/deviceauth_basic_deps/BUILD.gn
+0
-150
security_lite/deviceauth_basic_deps/README.md
security_lite/deviceauth_basic_deps/README.md
+0
-8
security_lite/deviceauth_basic_deps/Test.tmpl
security_lite/deviceauth_basic_deps/Test.tmpl
+0
-19
security_lite/deviceauth_basic_deps/deviceauth.gni
security_lite/deviceauth_basic_deps/deviceauth.gni
+0
-66
security_lite/deviceauth_basic_deps/hc_alg_test.c
security_lite/deviceauth_basic_deps/hc_alg_test.c
+0
-1657
security_lite/deviceauth_basic_deps/hc_alg_test.h
security_lite/deviceauth_basic_deps/hc_alg_test.h
+0
-29
security_lite/deviceauth_basic_deps/hc_alg_test_case.h
security_lite/deviceauth_basic_deps/hc_alg_test_case.h
+0
-727
security_lite/deviceauth_basic_deps/hc_condition_test.c
security_lite/deviceauth_basic_deps/hc_condition_test.c
+0
-312
security_lite/deviceauth_basic_deps/hc_condition_test.h
security_lite/deviceauth_basic_deps/hc_condition_test.h
+0
-36
security_lite/deviceauth_basic_deps/hc_dev_info_test.c
security_lite/deviceauth_basic_deps/hc_dev_info_test.c
+0
-86
security_lite/deviceauth_basic_deps/hc_dev_info_test.h
security_lite/deviceauth_basic_deps/hc_dev_info_test.h
+0
-29
security_lite/deviceauth_basic_deps/hc_file_common.c
security_lite/deviceauth_basic_deps/hc_file_common.c
+0
-41
security_lite/deviceauth_basic_deps/hc_file_common.h
security_lite/deviceauth_basic_deps/hc_file_common.h
+0
-46
security_lite/deviceauth_basic_deps/hc_file_f_test.c
security_lite/deviceauth_basic_deps/hc_file_f_test.c
+0
-237
security_lite/deviceauth_basic_deps/hc_file_f_test.h
security_lite/deviceauth_basic_deps/hc_file_f_test.h
+0
-29
security_lite/deviceauth_basic_deps/hc_file_iot_flash_test.c
security_lite/deviceauth_basic_deps/hc_file_iot_flash_test.c
+0
-277
security_lite/deviceauth_basic_deps/hc_file_iot_flash_test.h
security_lite/deviceauth_basic_deps/hc_file_iot_flash_test.h
+0
-29
security_lite/deviceauth_basic_deps/hc_file_test.c
security_lite/deviceauth_basic_deps/hc_file_test.c
+0
-212
security_lite/deviceauth_basic_deps/hc_file_test.h
security_lite/deviceauth_basic_deps/hc_file_test.h
+0
-29
security_lite/deviceauth_basic_deps/hc_file_utils_test.c
security_lite/deviceauth_basic_deps/hc_file_utils_test.c
+0
-134
security_lite/deviceauth_basic_deps/hc_file_utils_test.h
security_lite/deviceauth_basic_deps/hc_file_utils_test.h
+0
-29
security_lite/deviceauth_basic_deps/hc_mutex_test.c
security_lite/deviceauth_basic_deps/hc_mutex_test.c
+0
-158
security_lite/deviceauth_basic_deps/hc_mutex_test.h
security_lite/deviceauth_basic_deps/hc_mutex_test.h
+0
-29
security_lite/deviceauth_basic_deps/hc_thread_mutex_share.h
security_lite/deviceauth_basic_deps/hc_thread_mutex_share.h
+0
-28
security_lite/deviceauth_basic_deps/hc_thread_test.c
security_lite/deviceauth_basic_deps/hc_thread_test.c
+0
-183
security_lite/deviceauth_basic_deps/hc_thread_test.h
security_lite/deviceauth_basic_deps/hc_thread_test.h
+0
-29
security_lite/deviceauth_basic_deps/hc_time_test.c
security_lite/deviceauth_basic_deps/hc_time_test.c
+0
-126
security_lite/deviceauth_basic_deps/hc_time_test.h
security_lite/deviceauth_basic_deps/hc_time_test.h
+0
-29
security_lite/deviceauth_basic_deps/print_log.c
security_lite/deviceauth_basic_deps/print_log.c
+0
-115
security_lite/deviceauth_basic_deps/print_log.h
security_lite/deviceauth_basic_deps/print_log.h
+0
-36
security_lite/deviceauth_basic_deps/test.c
security_lite/deviceauth_basic_deps/test.c
+0
-185
security_lite/deviceauth_basic_deps/test_timer.c
security_lite/deviceauth_basic_deps/test_timer.c
+0
-62
security_lite/deviceauth_basic_deps/test_timer.h
security_lite/deviceauth_basic_deps/test_timer.h
+0
-58
未找到文件。
security_lite/deviceauth_basic_deps/BUILD.gn
已删除
100644 → 0
浏览文件 @
4ecb7b3b
# Copyright (C) 2021 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("//test/xts/acts/security_lite/deviceauth_basic_deps/deviceauth.gni")
import("//test/xts/tools/lite/build/suite_lite.gni")
hctest_suite("ActsSecurityHichainBasicDeps") {
suite_name = "acts"
sources = [ "test.c" ]
sources += DEVICEAUTH_BASIC_DEPS_SOURCE
include_dirs = [
"//commonlibrary/c_utils/base/include",
"//commonlibrary/utils_lite/include",
"//test/xts/tools/lite/hctest/include",
"//third_party/unity/src",
"//foundation/systemabilitymgr/samgr_lite/interfaces/kits/samgr",
]
include_dirs += DEVICEAUTH_BASIC_DEPS_INC
deps = []
cflags = [ "-Werror" ]
ldflags = [
"-lstdc++",
"-lm",
"-lpthread",
]
defines = [
"MKDIR_IMPLEMENTED=0",
"STAT_IMPLEMENTED=0",
"ACCESS_IMPLEMENTED=0",
"F_API_IMPLEMENTED=0",
"FLASH_START_ADDRESS_HICHAIN=0",
"UTILS_FILE_IMPLEMENTED=1",
"TEST_PTHREAD_CREATE_DETACHED=0",
"TEST_HC_FILE_OPEN_SERIES=1",
]
defines += DEVICEAUTH_BASIC_DEPS_ALGORITHM_DEFINES
if (defined(ohos_lite)) {
include_dirs += [
"//base/security/device_auth/deps_adapter/os_adapter/interfaces/liteos",
]
if (ohos_kernel_type == "liteos_m") {
# liteos m
include_dirs +=
[ "//base/startup/init/interfaces/innerkits/include/syspara" ]
deps += [ "//base/startup/init/interfaces/innerkits:libbegetutil" ]
if (board_name == "rtl8720") {
cflags +=
[ "-isystem${ohos_root_path}/kernel/liteos_m/kal/posix/include" ]
defines -= [
"FLASH_START_ADDRESS_HICHAIN=0",
"TEST_HC_FILE_OPEN_SERIES=1",
"TEST_HKDF_WITH_KEY_ALIAS_TRUE=1",
"TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE=1",
"TEST_HASH_TO_POINT=1",
"TEST_GENERATE_KEY_PAIR_WITH_STORAGE=1",
"TEST_AGREE_SHARED_SECRET_WITH_STORAGE=1",
"TEST_AGREE_SHARED_SECRET=1",
"TEST_GENERATE_KEY_PAIR=1",
"TEST_EXPORT_PUBLIC_KEY=1",
"TEST_ALGORITHM_SIGN=1",
"TEST_ALGORITHM_VERIFY=1",
"TEST_IMPORT_PUBLIC_KEY=1",
"TEST_CHECK_KEY_EXIST=1",
"TEST_DELETE_KEY=1",
"TEST_AES_GCM_ENCRYPT=1",
"TEST_AES_GCM_DECRYPT=1",
]
defines += [
"FLASH_START_ADDRESS_HICHAIN=0x1F6000",
"TEST_HC_FILE_OPEN_SERIES=0",
"TEST_HKDF_WITH_KEY_ALIAS_TRUE=0",
"TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE=0",
"TEST_HASH_TO_POINT=0",
"TEST_GENERATE_KEY_PAIR_WITH_STORAGE=0",
"TEST_AGREE_SHARED_SECRET_WITH_STORAGE=0",
"TEST_AGREE_SHARED_SECRET=0",
"TEST_GENERATE_KEY_PAIR=0",
"TEST_EXPORT_PUBLIC_KEY=0",
"TEST_ALGORITHM_SIGN=0",
"TEST_ALGORITHM_VERIFY=0",
"TEST_IMPORT_PUBLIC_KEY=0",
"TEST_CHECK_KEY_EXIST=0",
"TEST_DELETE_KEY=0",
"TEST_AES_GCM_ENCRYPT=0",
"TEST_AES_GCM_DECRYPT=0",
]
defines += [ "DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY=1" ]
}
if (board_name == "hispark_pegasus") {
# 3861
defines -= [
"TEST_HKDF_WITH_KEY_ALIAS_TRUE=1",
"TEST_HASH_TO_POINT=1",
"TEST_GENERATE_KEY_PAIR_WITH_STORAGE=1",
"TEST_AGREE_SHARED_SECRET_WITH_STORAGE=1",
"TEST_AGREE_SHARED_SECRET=1",
"TEST_GENERATE_KEY_PAIR=1",
"TEST_EXPORT_PUBLIC_KEY=1",
"TEST_ALGORITHM_SIGN=1",
"TEST_ALGORITHM_VERIFY=1",
"TEST_IMPORT_PUBLIC_KEY=1",
]
defines += [
"TEST_HKDF_WITH_KEY_ALIAS_TRUE=0",
"TEST_HASH_TO_POINT=0",
"TEST_GENERATE_KEY_PAIR_WITH_STORAGE=0",
"TEST_AGREE_SHARED_SECRET_WITH_STORAGE=0",
"TEST_AGREE_SHARED_SECRET=0",
"TEST_GENERATE_KEY_PAIR=0",
"TEST_EXPORT_PUBLIC_KEY=0",
"TEST_ALGORITHM_SIGN=0",
"TEST_ALGORITHM_VERIFY=0",
"TEST_IMPORT_PUBLIC_KEY=0",
]
}
} else {
#liteos a or L1 linux
include_dirs +=
[ "//base/startup/init/interfaces/innerkits/include/syspara" ]
deps += [ "//base/startup/init/interfaces/innerkits:libbegetutil" ]
}
} else {
# linux
include_dirs += [
"//base/startup/init/interfaces/innerkits/include/syspara",
"//base/security/device_auth/deps_adapter/os_adapter/interfaces/linux",
]
deps += [ "//base/startup/init/interfaces/innerkits:libbegetutil" ]
}
}
security_lite/deviceauth_basic_deps/README.md
已删除
100644 → 0
浏览文件 @
4ecb7b3b
## wifiiot_hispark_pegasus
1.
compile command:
```
bash
cd test
/xts/tools/lite
./build.sh
product
=
wifiiot
xts
=
acts
target
=
//test/xts/acts/security_lite/deviceauth_basic_deps:ActsSecurityHichainBasicDeps
```
security_lite/deviceauth_basic_deps/Test.tmpl
已删除
100644 → 0
浏览文件 @
4ecb7b3b
{
"description": "Config for $module test cases",
"environment": [
{
"type": "device",
"label": "wifiiot"
}
],
"kits": [
{
"type": "DeployKit",
"timeout": "20000",
"burn_file": "$subsystem/$module.bin"
}
],
"driver": {
"type": "CTestLite"
}
}
\ No newline at end of file
security_lite/deviceauth_basic_deps/deviceauth.gni
已删除
100644 → 0
浏览文件 @
4ecb7b3b
# Copyright (C) 2021 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
DEVICEAUTH_BASIC_DEPS_DIR =
"//test/xts/acts/security_lite/deviceauth_basic_deps"
DEVICEAUTH_BASIC_DEPS_SOURCE = [
"${DEVICEAUTH_BASIC_DEPS_DIR}/print_log.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/test_timer.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_file_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_mutex_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_file_f_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_thread_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_dev_info_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_condition_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_file_utils_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_file_iot_flash_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_time_test.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_file_common.c",
"${DEVICEAUTH_BASIC_DEPS_DIR}/hc_alg_test.c",
]
DEVICEAUTH_BASIC_DEPS_INC = [
"//base/iothardware/peripheral/interfaces/inner_api",
"//commonlibrary/utils_lite/include", # utils_file.h ohos_types.h
# alg test
"//base/security/device_auth/deps_adapter/key_management_adapter/interfaces",
"//base/security/device_auth/deps_adapter/os_adapter/interfaces",
"//base/security/device_auth/common_lib/interfaces",
"//base/security/device_auth/interfaces/innerkits",
]
DEVICEAUTH_BASIC_DEPS_ALGORITHM_DEFINES = [
"TEST_HKDF_WITH_KEY_ALIAS_TRUE=1",
"TEST_IMPORT_SYMMETRIC_KEY=1",
"TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE=1",
"TEST_HASH_TO_POINT=1",
"TEST_GENERATE_KEY_PAIR_WITH_STORAGE=1",
"TEST_AGREE_SHARED_SECRET_WITH_STORAGE=1",
"TEST_AGREE_SHARED_SECRET=1",
"TEST_BIG_NUM_EXP_MOD=1",
"TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519=1",
"TEST_EXPORT_IMPORT_SIGN_VERIFY_P256=1",
"TEST_BIG_NUM_COMPARE=1",
"TEST_GENERATE_KEY_PAIR=1",
"TEST_EXPORT_PUBLIC_KEY=1",
"TEST_ALGORITHM_SIGN=1",
"TEST_ALGORITHM_VERIFY=1",
"TEST_IMPORT_PUBLIC_KEY=1",
"TEST_CHECK_DL_PUBLIC_KEY=1",
"TEST_CHECK_KEY_EXIST=1",
"TEST_DELETE_KEY=1",
"TEST_AES_GCM_ENCRYPT=1",
"TEST_AES_GCM_DECRYPT=1",
]
security_lite/deviceauth_basic_deps/hc_alg_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_alg_test.h"
#include <alg_loader.h>
#include <device_auth.h>
#include <hal_error.h>
#include <hctest.h>
#include <stdlib.h>
#include <string_util.h>
#include <unistd.h>
#include "hc_alg_test_case.h"
#include "print_log.h"
#include "test_timer.h"
#define LOG_ERROR_IF_POINTER_NULL(pointer) LOGE("Pointer %s is %s", #pointer, ((pointer) == NULL ? "NULL" : "not NULL"))
#ifdef __cplusplus
extern
"C"
{
#endif
static
uint32_t
CountZero
(
const
uint8_t
*
buffer
,
uint32_t
length
)
{
uint32_t
zeroCount
=
0
;
for
(
uint32_t
i
=
0
;
i
<
length
;
++
i
)
{
if
(
buffer
[
i
]
==
0
)
{
++
zeroCount
;
}
}
return
zeroCount
;
}
static
void
FillRandom
(
uint8_t
*
msg
,
uint32_t
setZeroLength
,
uint32_t
randomLength
)
{
if
(
randomLength
<
1
)
{
return
;
}
int
res
;
res
=
memset_s
(
msg
,
setZeroLength
,
0
,
setZeroLength
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
msg
[
0
]
=
rand
()
%
(
UINT8_MAX
-
1
)
+
1
;
for
(
uint32_t
i
=
1
;
i
<
randomLength
;
++
i
)
{
msg
[
i
]
=
rand
()
%
UINT8_MAX
;
}
enum
{
// ignore rand correctness if the random length is equal or less than 3
RANDOM_CONSECUTIVE_ZERO_LENGTH_LIMIT
=
3
,
};
if
(
randomLength
<=
RANDOM_CONSECUTIVE_ZERO_LENGTH_LIMIT
+
1
)
{
return
;
}
TEST_ASSERT_NOT_EQUAL
(
randomLength
-
1
,
CountZero
(
msg
+
1
,
randomLength
-
1
));
}
// Note: sha256 and sha256Compare will be set to all zero
static
void
TestSha256Inner
(
const
AlgLoader
*
loader
,
Uint8Buff
*
msg
,
Uint8Buff
*
sha256
,
Uint8Buff
*
sha256Compare
)
{
int
res
;
res
=
memset_s
(
sha256
->
val
,
SHA256_LEN
,
0
,
SHA256_LEN
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
res
=
memset_s
(
sha256Compare
->
val
,
SHA256_LEN
,
0
,
SHA256_LEN
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
sha256
(
msg
,
sha256
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
TEST_ASSERT_EQUAL
((
uint32_t
)
SHA256_LEN
,
sha256
->
length
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
sha256
(
msg
,
sha256Compare
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
TEST_ASSERT_EQUAL
((
uint32_t
)
SHA256_LEN
,
sha256Compare
->
length
);
uint32_t
zeroCount
=
CountZero
(
sha256
->
val
,
sha256
->
length
);
TEST_ASSERT_NOT_EQUAL_MESSAGE
((
uint32_t
)
SHA256_LEN
,
zeroCount
,
"invalid all zero sha256"
);
TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE
(
sha256
->
val
,
sha256Compare
->
val
,
SHA256_LEN
,
"different sha256 against the same message"
);
}
static
void
TestSha256
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
sha256
);
if
(
loader
->
sha256
==
NULL
)
{
LOGE
(
"sha256 pointer is NULL! will not test!"
);
return
;
}
Uint8Buff
msg
=
{
(
uint8_t
*
)
malloc
(
SHA256_MSG_MAX_SIZE
),
SHA256_MSG_MAX_SIZE
};
TEST_ASSERT_NOT_NULL
(
msg
.
val
);
Uint8Buff
sha256
=
{
(
uint8_t
*
)
malloc
(
SHA256_LEN
),
SHA256_LEN
};
TEST_ASSERT_NOT_NULL
(
sha256
.
val
);
Uint8Buff
sha256Compare
=
{
(
uint8_t
*
)
malloc
(
SHA256_LEN
),
SHA256_LEN
};
TEST_ASSERT_NOT_NULL
(
sha256Compare
.
val
);
for
(
int
i
=
1
;
i
<=
SHA256_TEST_MIN_LIMIT
;
++
i
)
{
msg
.
length
=
i
;
LOGI
(
"test sha256 with msg length %d"
,
msg
.
length
);
FillRandom
(
msg
.
val
,
SHA256_MSG_MAX_SIZE
,
msg
.
length
);
TestSha256Inner
(
loader
,
&
msg
,
&
sha256
,
&
sha256Compare
);
}
msg
.
length
=
SHA256_MSG_MAX_SIZE
;
LOGI
(
"test sha256 with max msg length %d"
,
msg
.
length
);
FillRandom
(
msg
.
val
,
SHA256_MSG_MAX_SIZE
,
msg
.
length
);
TestSha256Inner
(
loader
,
&
msg
,
&
sha256
,
&
sha256Compare
);
for
(
int
i
=
0
;
i
<
SHA256_TEST_TIMES
;
++
i
)
{
msg
.
length
=
rand
()
%
SHA256_MSG_MAX_SIZE
+
1
;
LOGI
(
"test sha256 with random msg length %d"
,
msg
.
length
);
FillRandom
(
msg
.
val
,
SHA256_MSG_MAX_SIZE
,
msg
.
length
);
TestSha256Inner
(
loader
,
&
msg
,
&
sha256
,
&
sha256Compare
);
}
msg
.
val
=
(
uint8_t
*
)(
SHA256_EXAMPLE_MESSAGE
);
msg
.
length
=
strlen
(
SHA256_EXAMPLE_MESSAGE
);
TestSha256Inner
(
loader
,
&
msg
,
&
sha256
,
&
sha256Compare
);
TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE
(
sha256
.
val
,
SHA256_EXAMPLE_RESULT
,
SHA256_LEN
,
"incorrect sha256 result"
);
PrintBuffer
(
SHA256_EXAMPLE_MESSAGE
,
sha256
.
val
,
sha256
.
length
);
free
(
msg
.
val
);
free
(
sha256
.
val
);
free
(
sha256Compare
.
val
);
}
static
void
TestGenerateRandomInner
(
const
AlgLoader
*
loader
,
Uint8Buff
*
random
)
{
uint32_t
randomLength
=
random
->
length
;
int
res
;
res
=
memset_s
(
random
->
val
,
GEN_RANDOM_MAX_SIZE
,
0
,
GEN_RANDOM_MAX_SIZE
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
generateRandom
(
random
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
TEST_ASSERT_EQUAL
(
randomLength
,
random
->
length
);
uint32_t
zeroCount
=
CountZero
(
random
->
val
,
random
->
length
);
TEST_ASSERT_NOT_EQUAL_MESSAGE
(
random
->
length
,
zeroCount
,
"random all zero"
);
}
static
void
TestGenerateRandomNoPeriodicRepetition
(
const
AlgLoader
*
loader
,
Uint8Buff
*
previous
,
Uint8Buff
*
current
)
{
int
res
;
res
=
memset_s
(
previous
->
val
,
GEN_RANDOM_TEST_REPEAT_SIZE
,
0
,
GEN_RANDOM_TEST_REPEAT_SIZE
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
for
(
int
i
=
0
;
i
<
GEN_RANDOM_TEST_REPEAT_TIMES
;
++
i
)
{
res
=
memset_s
(
current
->
val
,
GEN_RANDOM_TEST_REPEAT_SIZE
,
0
,
GEN_RANDOM_TEST_REPEAT_SIZE
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
generateRandom
(
current
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
TEST_ASSERT_EQUAL
(
GEN_RANDOM_TEST_REPEAT_SIZE
,
current
->
length
);
int
equalCount
=
0
;
for
(
int
j
=
0
;
j
<
GEN_RANDOM_TEST_REPEAT_SIZE
;
++
j
)
{
if
(
previous
->
val
[
j
]
==
current
->
val
[
j
])
{
++
equalCount
;
}
}
TEST_ASSERT_NOT_EQUAL_MESSAGE
(
GEN_RANDOM_TEST_REPEAT_SIZE
,
equalCount
,
"random is the same as previous generated"
);
res
=
memcpy_s
(
previous
->
val
,
GEN_RANDOM_TEST_REPEAT_SIZE
,
current
->
val
,
GEN_RANDOM_TEST_REPEAT_SIZE
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
}
}
static
void
TestGenerateRandom
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
generateRandom
);
if
(
loader
->
generateRandom
==
NULL
)
{
LOGE
(
"generateRandom pointer is NULL! will not test!"
);
return
;
}
Uint8Buff
random
=
{
(
uint8_t
*
)
malloc
(
GEN_RANDOM_MAX_SIZE
),
GEN_RANDOM_MAX_SIZE
};
TEST_ASSERT_NOT_NULL
(
random
.
val
);
for
(
int
i
=
1
;
i
<=
GEN_RANDOM_MIN_LIMIT
;
++
i
)
{
random
.
length
=
i
;
LOGI
(
"test generate random with length %d"
,
random
.
length
);
TestGenerateRandomInner
(
loader
,
&
random
);
}
random
.
length
=
GEN_RANDOM_MAX_SIZE
;
LOGI
(
"test generate random with max length %d"
,
random
.
length
);
TestGenerateRandomInner
(
loader
,
&
random
);
for
(
int
i
=
0
;
i
<
GEN_RANDOM_TEST_TIMES
;
++
i
)
{
random
.
length
=
rand
()
%
GEN_RANDOM_MAX_SIZE
+
1
;
LOGI
(
"test generate random with random length %d"
,
random
.
length
);
TestGenerateRandomInner
(
loader
,
&
random
);
}
// test whether the random number is repeated
Uint8Buff
previousUint8Buff
=
{
(
uint8_t
*
)
malloc
(
GEN_RANDOM_TEST_REPEAT_SIZE
),
GEN_RANDOM_TEST_REPEAT_SIZE
};
TEST_ASSERT_NOT_NULL
(
previousUint8Buff
.
val
);
Uint8Buff
currentUint8Buff
=
{
(
uint8_t
*
)
malloc
(
GEN_RANDOM_TEST_REPEAT_SIZE
),
GEN_RANDOM_TEST_REPEAT_SIZE
};
TEST_ASSERT_NOT_NULL
(
currentUint8Buff
.
val
);
TestGenerateRandomNoPeriodicRepetition
(
loader
,
&
previousUint8Buff
,
&
currentUint8Buff
);
free
(
currentUint8Buff
.
val
);
free
(
previousUint8Buff
.
val
);
free
(
random
.
val
);
}
// key will not be modified
// message will be malloced if message->val is NULL
// hmac will be clear with zero
static
void
TestComputeHmacInner
(
const
AlgLoader
*
loader
,
const
Uint8Buff
*
key
,
Uint8Buff
*
msg
,
Uint8Buff
*
hmac
,
bool
isAlias
)
{
int32_t
res
;
bool
allocMemory
=
false
;
if
(
msg
->
val
==
NULL
)
{
msg
->
val
=
(
uint8_t
*
)
malloc
(
msg
->
length
);
TEST_ASSERT_NOT_NULL
(
msg
->
val
);
allocMemory
=
true
;
res
=
memset_s
(
msg
->
val
,
msg
->
length
,
0
,
msg
->
length
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
FillRandom
(
msg
->
val
,
msg
->
length
,
msg
->
length
);
}
res
=
memset_s
(
hmac
->
val
,
hmac
->
length
,
0
,
hmac
->
length
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
computeHmac
(
key
,
msg
,
hmac
,
isAlias
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
uint32_t
zeroCount
=
CountZero
(
hmac
->
val
,
hmac
->
length
);
TEST_ASSERT_NOT_EQUAL_MESSAGE
(
hmac
->
length
,
zeroCount
,
"invalid all zero hmac"
);
if
(
allocMemory
&&
msg
->
val
!=
NULL
)
{
free
(
msg
->
val
);
msg
->
val
=
NULL
;
}
}
static
void
TestComputeHmacWithIsAliasTrue
(
const
AlgLoader
*
loader
,
Uint8Buff
*
msg
,
Uint8Buff
*
hmacKeyBuff
,
Uint8Buff
*
outHmacBuff
)
#if TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE
{
TEST_ASSERT_NOT_NULL
(
loader
->
importSymmetricKey
);
if
(
!
loader
->
importSymmetricKey
)
{
LOGE
(
"importSymmetricKey is NULL, can not test computeHmac with isAlias true"
);
return
;
}
LOGI
(
"test hmac for isAlias true"
);
msg
->
val
=
(
uint8_t
*
)
NULL
;
msg
->
length
=
TEST_HMAC_ISALIAS_TRUE_MSG_LENGTH
;
FillRandom
(
hmacKeyBuff
->
val
,
hmacKeyBuff
->
length
,
hmacKeyBuff
->
length
);
// write key with specified alias first, then do the test
const
ExtraInfo
info
=
{
.
authId
=
*
hmacKeyBuff
,
.
userType
=
DEVICE_TYPE_ACCESSORY
,
.
pairType
=
PAIR_TYPE_BIND
,
};
int
res
=
loader
->
importSymmetricKey
(
hmacKeyBuff
,
hmacKeyBuff
,
KEY_PURPOSE_MAC
,
&
info
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
TestComputeHmacInner
(
loader
,
hmacKeyBuff
,
msg
,
outHmacBuff
,
true
);
// delete key after the test
if
(
loader
->
deleteKey
)
{
LOGD
(
"test deleteKey"
);
res
=
loader
->
deleteKey
(
hmacKeyBuff
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
}
}
#else // TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE
{
LOGE
(
"no TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE, do not test computeHmac with isAlias true"
);
#if (defined(DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY) && DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY)
(
void
)(
loader
);
#else // DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY
TEST_ASSERT_NULL
(
loader
->
importSymmetricKey
);
#endif // DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY
(
void
)(
msg
);
(
void
)(
hmacKeyBuff
);
(
void
)(
outHmacBuff
);
}
#endif // TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE
static
void
TestComputeHmac
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
computeHmac
);
if
(
loader
->
computeHmac
==
NULL
)
{
LOGE
(
"computeHmac pointer is NULL! will not test!"
);
return
;
}
Uint8Buff
hmacKeyBuff
=
{
(
uint8_t
*
)
malloc
(
TEST_HMAC_KEY_LEN
),
TEST_HMAC_KEY_LEN
};
TEST_ASSERT_NOT_NULL
(
hmacKeyBuff
.
val
);
Uint8Buff
msg
=
{
(
uint8_t
*
)
NULL
,
0
};
uint8_t
*
outHmac
=
(
uint8_t
*
)
malloc
(
HMAC_LEN
);
TEST_ASSERT_NOT_NULL
(
outHmac
);
Uint8Buff
outHmacBuff
=
{
(
uint8_t
*
)
outHmac
,
HMAC_LEN
};
TestComputeHmacWithIsAliasTrue
(
loader
,
&
msg
,
&
hmacKeyBuff
,
&
outHmacBuff
);
LOGI
(
"test hmac for isAlias false"
);
for
(
uint32_t
i
=
0
;
i
<
ARRAY_SIZE
(
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_ARRAY
);
++
i
)
{
msg
.
val
=
(
uint8_t
*
)
NULL
;
msg
.
length
=
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_ARRAY
[
i
];
LOGI
(
"test hmac for msg length %d"
,
msg
.
length
);
FillRandom
(
hmacKeyBuff
.
val
,
hmacKeyBuff
.
length
,
hmacKeyBuff
.
length
);
TestComputeHmacInner
(
loader
,
&
hmacKeyBuff
,
&
msg
,
&
outHmacBuff
,
false
);
}
free
(
hmacKeyBuff
.
val
);
hmacKeyBuff
.
val
=
(
uint8_t
*
)
NULL
;
LOGI
(
"test the correctness of hmac"
);
hmacKeyBuff
.
val
=
(
uint8_t
*
)(
HMAC_EXAMPLE_KEY
),
hmacKeyBuff
.
length
=
sizeof
(
HMAC_EXAMPLE_KEY
);
msg
.
val
=
(
uint8_t
*
)(
HMAC_EXAMPLE_MESSAGE
),
msg
.
length
=
strlen
(
HMAC_EXAMPLE_MESSAGE
);
TestComputeHmacInner
(
loader
,
&
hmacKeyBuff
,
&
msg
,
&
outHmacBuff
,
false
);
TEST_ASSERT_EQUAL
(
sizeof
(
HMAC_EXAMPLE_RESULT
),
outHmacBuff
.
length
);
TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE
(
HMAC_EXAMPLE_RESULT
,
outHmacBuff
.
val
,
sizeof
(
HMAC_EXAMPLE_RESULT
),
"incorrect hmac result"
);
PrintBuffer
(
"hmac"
,
outHmacBuff
.
val
,
outHmacBuff
.
length
);
free
(
outHmac
);
outHmac
=
NULL
;
outHmacBuff
.
val
=
(
uint8_t
*
)
NULL
;
}
struct
HkdfArgument
{
Uint8Buff
baseKey
;
Uint8Buff
salt
;
Uint8Buff
keyInfo
;
Uint8Buff
outHkdf
;
bool
isAlias
;
};
// baseKey, salt will be malloced and fill random if NULL
// keyInfo, isAlias will not be modified
// outHkdf will be clear with zero
static
void
TestComputeHkdfInner
(
const
AlgLoader
*
loader
,
struct
HkdfArgument
*
arg
)
{
bool
baseAlloced
=
false
,
saltAlloced
=
false
;
if
(
arg
->
baseKey
.
val
==
NULL
)
{
arg
->
baseKey
.
val
=
(
uint8_t
*
)
malloc
(
arg
->
baseKey
.
length
);
TEST_ASSERT_NOT_NULL
(
arg
->
baseKey
.
val
);
baseAlloced
=
true
;
FillRandom
(
arg
->
baseKey
.
val
,
arg
->
baseKey
.
length
,
arg
->
baseKey
.
length
);
}
if
(
arg
->
salt
.
val
==
NULL
)
{
arg
->
salt
.
val
=
(
uint8_t
*
)
malloc
(
arg
->
salt
.
length
);
TEST_ASSERT_NOT_NULL
(
arg
->
salt
.
val
);
saltAlloced
=
true
;
FillRandom
(
arg
->
salt
.
val
,
arg
->
salt
.
length
,
arg
->
salt
.
length
);
}
int32_t
res
;
res
=
memset_s
(
arg
->
outHkdf
.
val
,
arg
->
outHkdf
.
length
,
0
,
arg
->
outHkdf
.
length
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
computeHkdf
(
&
arg
->
baseKey
,
&
arg
->
salt
,
&
arg
->
keyInfo
,
&
arg
->
outHkdf
,
arg
->
isAlias
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
if
(
saltAlloced
&&
arg
->
salt
.
val
!=
NULL
)
{
free
(
arg
->
salt
.
val
);
arg
->
salt
.
val
=
(
uint8_t
*
)
NULL
;
}
if
(
baseAlloced
&&
arg
->
baseKey
.
val
!=
NULL
)
{
free
(
arg
->
baseKey
.
val
);
arg
->
baseKey
.
val
=
(
uint8_t
*
)
NULL
;
}
uint32_t
zeroCount
=
CountZero
(
arg
->
outHkdf
.
val
,
arg
->
outHkdf
.
length
);
TEST_ASSERT_NOT_EQUAL_MESSAGE
(
arg
->
outHkdf
.
length
,
zeroCount
,
"invalid all zero hkdf result"
);
}
#if TEST_HKDF_WITH_KEY_ALIAS_TRUE // {
static
void
TestComputeHkdfWithKeyAliasTrueFirstAndSecondStep
(
const
AlgLoader
*
loader
,
Uint8Buff
*
privKeyPairAlias
,
Uint8Buff
*
pubKeyPairAlias
,
ExtraInfo
*
extraInfo
,
Uint8Buff
*
sharedKeyAlias
)
{
LOGI
(
"First, generate two pairs of public-private key pairs"
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
generateKeyPairWithStorage
(
privKeyPairAlias
,
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH
,
ED25519
,
extraInfo
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
generateKeyPairWithStorage
(
pubKeyPairAlias
,
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH
,
ED25519
,
extraInfo
));
LOGI
(
"Second, agree shared key with privateKey and publicKey"
);
KeyBuff
privKeyBuff
=
{
privKeyPairAlias
->
val
,
privKeyPairAlias
->
length
,
true
};
KeyBuff
pubKeyBuff
=
{
pubKeyPairAlias
->
val
,
pubKeyPairAlias
->
length
,
true
};
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
agreeSharedSecretWithStorage
(
&
privKeyBuff
,
&
pubKeyBuff
,
ED25519
,
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_SHARED_KEY_LENGTH
,
sharedKeyAlias
));
}
static
void
TestComputeHkdfWithKeyAliasTrueThirdStep
(
const
AlgLoader
*
loader
,
struct
HkdfArgument
*
argument
,
Uint8Buff
*
sharedKeyAlias
)
{
LOGI
(
"Third, compute hkdf with shared key"
);
argument
->
baseKey
=
*
sharedKeyAlias
;
argument
->
salt
.
val
=
(
uint8_t
*
)
NULL
;
argument
->
salt
.
length
=
HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_SALT_LEN
;
argument
->
keyInfo
.
val
=
(
uint8_t
*
)(
TMP_AUTH_KEY_FACTOR
);
argument
->
keyInfo
.
length
=
strlen
(
TMP_AUTH_KEY_FACTOR
);
argument
->
outHkdf
.
val
=
(
uint8_t
*
)
malloc
(
HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_OUTKEY_LEN
);
TEST_ASSERT_NOT_NULL
(
argument
->
outHkdf
.
val
);
argument
->
outHkdf
.
length
=
HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_OUTKEY_LEN
;
argument
->
isAlias
=
true
;
TestComputeHkdfInner
(
loader
,
argument
);
free
(
argument
->
outHkdf
.
val
);
argument
->
outHkdf
.
val
=
(
uint8_t
*
)
NULL
;
}
static
void
TestComputeHkdfWithKeyAliasTrue
(
const
AlgLoader
*
loader
,
struct
HkdfArgument
*
argument
)
{
LOGI
(
"pake psk derive secret keyAlias true"
);
TEST_ASSERT_NOT_NULL
(
loader
->
generateKeyPairWithStorage
);
TEST_ASSERT_NOT_NULL
(
loader
->
agreeSharedSecretWithStorage
);
if
(
!
loader
->
generateKeyPairWithStorage
||
!
loader
->
agreeSharedSecretWithStorage
)
{
LOGE
(
"generateKeyPairWithStorage or agreeSharedSecretWithStorage pointer is NULL! "
"can not test hkdf with alias true!"
);
return
;
}
Uint8Buff
privKeyPairAlias
=
{
(
uint8_t
*
)
malloc
(
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH
),
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH
};
Uint8Buff
pubKeyPairAlias
=
{
(
uint8_t
*
)
malloc
(
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH
),
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH
};
ExtraInfo
extraInfo
=
{
{
(
uint8_t
*
)
malloc
(
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_AUTH_ID_LENGTH
),
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_AUTH_ID_LENGTH
},
DEVICE_TYPE_ACCESSORY
,
PAIR_TYPE_BIND
};
TEST_ASSERT_NOT_NULL
(
privKeyPairAlias
.
val
);
TEST_ASSERT_NOT_NULL
(
pubKeyPairAlias
.
val
);
TEST_ASSERT_NOT_NULL
(
extraInfo
.
authId
.
val
);
FillRandom
(
privKeyPairAlias
.
val
,
privKeyPairAlias
.
length
,
privKeyPairAlias
.
length
);
FillRandom
(
pubKeyPairAlias
.
val
,
pubKeyPairAlias
.
length
,
pubKeyPairAlias
.
length
);
FillRandom
(
extraInfo
.
authId
.
val
,
extraInfo
.
authId
.
length
,
extraInfo
.
authId
.
length
);
Uint8Buff
sharedKeyAlias
=
{
(
uint8_t
*
)
malloc
(
HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_BASEKEY_LEN
),
HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_BASEKEY_LEN
};
TEST_ASSERT_NOT_NULL
(
sharedKeyAlias
.
val
);
FillRandom
(
sharedKeyAlias
.
val
,
sharedKeyAlias
.
length
,
sharedKeyAlias
.
length
);
TestComputeHkdfWithKeyAliasTrueFirstAndSecondStep
(
loader
,
&
privKeyPairAlias
,
&
pubKeyPairAlias
,
&
extraInfo
,
&
sharedKeyAlias
);
TestComputeHkdfWithKeyAliasTrueThirdStep
(
loader
,
argument
,
&
sharedKeyAlias
);
if
(
loader
->
deleteKey
)
{
LOGD
(
"test deleteKey"
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
privKeyPairAlias
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
pubKeyPairAlias
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
sharedKeyAlias
));
}
LOGD
(
"At last, free all memories allocated"
);
free
(
privKeyPairAlias
.
val
);
privKeyPairAlias
.
val
=
(
uint8_t
*
)
NULL
;
free
(
pubKeyPairAlias
.
val
);
pubKeyPairAlias
.
val
=
(
uint8_t
*
)
NULL
;
free
(
extraInfo
.
authId
.
val
);
extraInfo
.
authId
.
val
=
(
uint8_t
*
)
NULL
;
free
(
sharedKeyAlias
.
val
);
sharedKeyAlias
.
val
=
(
uint8_t
*
)
NULL
;
}
#else // TEST_HKDF_WITH_KEY_ALIAS_TRUE // } {
static
void
TestComputeHkdfWithKeyAliasTrue
(
const
AlgLoader
*
loader
,
struct
HkdfArgument
*
argument
)
{
LOGE
(
"no TEST_HKDF_WITH_KEY_ALIAS_TRUE, do not test hkdf with key alias true"
);
TEST_ASSERT_TRUE
(
loader
->
generateKeyPairWithStorage
==
NULL
||
loader
->
agreeSharedSecretWithStorage
==
NULL
);
LOG_ERROR_IF_POINTER_NULL
(
loader
->
generateKeyPairWithStorage
);
LOG_ERROR_IF_POINTER_NULL
(
loader
->
agreeSharedSecretWithStorage
);
(
void
)(
argument
);
}
#endif // TEST_HKDF_WITH_KEY_ALIAS_TRUE // }
static
void
TestComputeHkdfCorrectness
(
const
AlgLoader
*
loader
,
struct
HkdfArgument
*
argument
)
{
LOGI
(
"test the correctness of hkdf"
);
argument
->
baseKey
.
val
=
(
uint8_t
*
)(
HKDF_EXAMPLE_MESSAGE
);
argument
->
baseKey
.
length
=
strlen
(
HKDF_EXAMPLE_MESSAGE
);
argument
->
salt
.
val
=
(
uint8_t
*
)(
HKDF_EXAMPLE_SALT
);
argument
->
salt
.
length
=
sizeof
(
HKDF_EXAMPLE_SALT
);
argument
->
keyInfo
.
val
=
(
uint8_t
*
)(
HKDF_EXAMPLE_INFO
);
argument
->
keyInfo
.
length
=
strlen
(
HKDF_EXAMPLE_INFO
);
argument
->
outHkdf
.
val
=
(
uint8_t
*
)
malloc
(
sizeof
(
HKDF_EXAMPLE_RESULT_KEY
));
TEST_ASSERT_NOT_NULL
(
argument
->
outHkdf
.
val
);
argument
->
outHkdf
.
length
=
sizeof
(
HKDF_EXAMPLE_RESULT_KEY
);
argument
->
isAlias
=
false
;
TestComputeHkdfInner
(
loader
,
argument
);
TEST_ASSERT_EQUAL
(
sizeof
(
HKDF_EXAMPLE_RESULT_KEY
),
argument
->
outHkdf
.
length
);
TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE
(
HKDF_EXAMPLE_RESULT_KEY
,
argument
->
outHkdf
.
val
,
sizeof
(
HKDF_EXAMPLE_RESULT_KEY
),
"incorrect hkdf result"
);
PrintBuffer
(
"hkdf result"
,
argument
->
outHkdf
.
val
,
argument
->
outHkdf
.
length
);
free
(
argument
->
outHkdf
.
val
);
argument
->
outHkdf
.
val
=
(
uint8_t
*
)
NULL
;
}
static
void
TestComputeHkdf
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
computeHkdf
);
if
(
loader
->
computeHkdf
==
NULL
)
{
LOGE
(
"computeHkdf pointer is NULL! will not test!"
);
return
;
}
struct
HkdfArgument
argument
;
int
res
;
res
=
memset_s
(
&
argument
,
sizeof
(
argument
),
0
,
sizeof
(
argument
));
TEST_ASSERT_EQUAL
(
EOK
,
res
);
for
(
uint32_t
i
=
0
;
i
<
ARRAY_SIZE
(
g_hkdfTestCase
);
++
i
)
{
LOGI
(
"test case for:
\"
%s
\"
"
,
g_hkdfTestCase
[
i
].
caseName
);
LOGI
(
"test case for: baseKeyLength = %d, saltLength = %d, keyInfo =
\"
%s
\"
, outKeyLength = %d"
,
g_hkdfTestCase
[
i
].
baseKeyLength
,
g_hkdfTestCase
[
i
].
saltLength
,
g_hkdfTestCase
[
i
].
keyInfo
,
g_hkdfTestCase
[
i
].
outKeyLength
);
argument
.
baseKey
.
val
=
(
uint8_t
*
)
NULL
;
argument
.
baseKey
.
length
=
g_hkdfTestCase
[
i
].
baseKeyLength
;
argument
.
salt
.
val
=
(
uint8_t
*
)
NULL
;
argument
.
salt
.
length
=
g_hkdfTestCase
[
i
].
saltLength
;
argument
.
keyInfo
.
val
=
(
uint8_t
*
)(
g_hkdfTestCase
[
i
].
keyInfo
);
argument
.
keyInfo
.
length
=
strlen
(
g_hkdfTestCase
[
i
].
keyInfo
);
argument
.
outHkdf
.
val
=
(
uint8_t
*
)
malloc
(
g_hkdfTestCase
[
i
].
outKeyLength
);
TEST_ASSERT_NOT_NULL
(
argument
.
outHkdf
.
val
);
argument
.
outHkdf
.
length
=
g_hkdfTestCase
[
i
].
outKeyLength
;
argument
.
isAlias
=
false
;
TestComputeHkdfInner
(
loader
,
&
argument
);
free
(
argument
.
outHkdf
.
val
);
argument
.
outHkdf
.
val
=
(
uint8_t
*
)
NULL
;
}
TestComputeHkdfWithKeyAliasTrue
(
loader
,
&
argument
);
TestComputeHkdfCorrectness
(
loader
,
&
argument
);
}
#if TEST_IMPORT_SYMMETRIC_KEY // {
enum
{
WAIT_FOR_WATCH_DOG
=
1
,
};
static
void
TestImportSymmetricKey
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
importSymmetricKey
);
if
(
loader
->
importSymmetricKey
==
NULL
)
{
LOGE
(
"importSymmetricKey pointer is NULL! will not test!"
);
return
;
}
int
res
;
const
uint32_t
authIdLenArray
[]
=
{
TEST_IMPORT_SYMMETRIC_KEY_AUTH_ID_LENGTH_32
,
TEST_IMPORT_SYMMETRIC_KEY_AUTH_ID_LENGTH_64
};
for
(
uint32_t
i
=
0
;
i
<
ARRAY_SIZE
(
authIdLenArray
);
++
i
)
{
for
(
uint32_t
j
=
IMPORT_SYMMETRIC_KEY_KEYALIAS_LEN_MIN
;
j
<=
IMPORT_SYMMETRIC_KEY_KEYALIAS_LEN_MAX
;
++
j
)
{
LOGD
(
"auth id length = %u, msg length = %u"
,
authIdLenArray
[
i
],
j
);
Uint8Buff
keyAlias
=
{
(
uint8_t
*
)
malloc
(
j
),
j
};
Uint8Buff
authToken
=
{
(
uint8_t
*
)
malloc
(
IMPORT_SYMMETRIC_KEY_AUTHTOKEN_LEN
),
IMPORT_SYMMETRIC_KEY_AUTHTOKEN_LEN
};
ExtraInfo
extraInfo
=
{
{
(
uint8_t
*
)
malloc
(
authIdLenArray
[
i
]),
authIdLenArray
[
i
]
},
DEVICE_TYPE_ACCESSORY
,
PAIR_TYPE_BIND
};
TEST_ASSERT_NOT_NULL
(
keyAlias
.
val
);
TEST_ASSERT_NOT_NULL
(
authToken
.
val
);
TEST_ASSERT_NOT_NULL
(
extraInfo
.
authId
.
val
);
FillRandom
(
keyAlias
.
val
,
keyAlias
.
length
,
keyAlias
.
length
);
FillRandom
(
authToken
.
val
,
authToken
.
length
,
authToken
.
length
);
FillRandom
(
extraInfo
.
authId
.
val
,
extraInfo
.
authId
.
length
,
extraInfo
.
authId
.
length
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
importSymmetricKey
(
&
keyAlias
,
&
authToken
,
KEY_PURPOSE_MAC
,
&
extraInfo
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
if
(
loader
->
checkKeyExist
)
{
LOGD
(
"test checkKeyExist"
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkKeyExist
(
&
keyAlias
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
}
if
(
loader
->
deleteKey
)
{
LOGD
(
"test delete"
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
deleteKey
(
&
keyAlias
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
}
free
(
keyAlias
.
val
);
keyAlias
.
val
=
(
uint8_t
*
)
NULL
;
free
(
authToken
.
val
);
authToken
.
val
=
(
uint8_t
*
)
NULL
;
free
(
extraInfo
.
authId
.
val
);
extraInfo
.
authId
.
val
=
(
uint8_t
*
)
NULL
;
}
LOGI
(
"sleep for %d seconds, waiting for watch dog"
,
WAIT_FOR_WATCH_DOG
);
sleep
(
WAIT_FOR_WATCH_DOG
);
}
}
#else // TEST_IMPORT_SYMMETRIC_KEY // } {
static
void
TestImportSymmetricKey
(
const
AlgLoader
*
loader
)
{
LOGE
(
"no TEST_IMPORT_SYMMETRIC_KEY, do not test importSymmetricKey"
);
TEST_ASSERT_NULL
(
loader
->
importSymmetricKey
);
}
#endif // TEST_IMPORT_SYMMETRIC_KEY // }
static
void
TestCheckKeyExist
(
const
AlgLoader
*
loader
)
#if TEST_CHECK_KEY_EXIST
{
TEST_ASSERT_NOT_NULL
(
loader
->
checkKeyExist
);
if
(
loader
->
checkKeyExist
==
NULL
)
{
LOGE
(
"checkKeyExist pointer is NULL! will not test!"
);
return
;
}
const
char
bufferKeyAlias
[]
=
"A non-existent key"
;
Uint8Buff
keyAlias
=
{
.
val
=
(
uint8_t
*
)
bufferKeyAlias
,
.
length
=
strlen
(
bufferKeyAlias
),
};
int32_t
res
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkKeyExist
(
&
keyAlias
));
TEST_ASSERT_NOT_EQUAL
(
HAL_SUCCESS
,
res
);
}
#else // TEST_CHECK_KEY_EXIST
{
LOGE
(
"no TEST_CHECK_KEY_EXIST, do not test checkKeyExist"
);
TEST_ASSERT_NULL
(
loader
->
checkKeyExist
);
}
#endif // TEST_CHECK_KEY_EXIST
static
void
TestDeleteKey
(
const
AlgLoader
*
loader
)
#if TEST_DELETE_KEY
{
TEST_ASSERT_NOT_NULL
(
loader
->
deleteKey
);
if
(
loader
->
deleteKey
==
NULL
)
{
LOGE
(
"deleteKey pointer is NULL! will not test!"
);
return
;
}
const
char
bufferKeyAlias
[]
=
"A non-existent key"
;
Uint8Buff
keyAlias
=
{
.
val
=
(
uint8_t
*
)
bufferKeyAlias
,
.
length
=
strlen
(
bufferKeyAlias
),
};
int32_t
res
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
deleteKey
(
&
keyAlias
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
}
#else // TEST_DELETE_KEY
{
LOGE
(
"no TEST_DELETE_KEY, do not test deleteKey"
);
TEST_ASSERT_NULL
(
loader
->
deleteKey
);
}
#endif // TEST_DELETE_KEY
static
void
TestAesGcmEncrypt
(
const
AlgLoader
*
loader
)
#if TEST_AES_GCM_ENCRYPT
{
LOGI
(
"begin to test the AES-GCM algorithm encryption"
);
TEST_ASSERT_NOT_NULL
(
loader
->
aesGcmEncrypt
);
if
(
loader
->
aesGcmEncrypt
==
NULL
)
{
LOGE
(
"aesGcmEncrypt pointer is NULL! will not test!"
);
return
;
}
const
Uint8Buff
key
=
{
(
uint8_t
*
)
AES_GCM_TEST_KEY
,
AES_GCM_KEY_LEN
};
const
Uint8Buff
plainBuffer
=
{
(
uint8_t
*
)
PLAIN_CASE
,
PLAIN_LEN
};
uint8_t
*
nonce
=
(
uint8_t
*
)
malloc
(
NONCE_SIZE
);
TEST_ASSERT_NOT_NULL
(
nonce
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
nonce
,
NONCE_SIZE
,
0
,
NONCE_SIZE
));
GcmParam
gcmParams
;
gcmParams
.
aad
=
(
uint8_t
*
)
EXCHANGE_AAD
;
gcmParams
.
aadLen
=
(
uint32_t
)
strlen
(
EXCHANGE_AAD
);
gcmParams
.
nonce
=
nonce
;
gcmParams
.
nonceLen
=
NONCE_SIZE
;
uint8_t
*
cipher
=
(
uint8_t
*
)
malloc
(
CIPHER_LEN
);
TEST_ASSERT_NOT_NULL
(
cipher
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
cipher
,
CIPHER_LEN
,
0
,
CIPHER_LEN
));
Uint8Buff
cipherBuffer
=
{
cipher
,
CIPHER_LEN
};
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
aesGcmEncrypt
(
&
key
,
&
plainBuffer
,
&
gcmParams
,
false
,
&
cipherBuffer
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
PrintBuffer
(
"AES-GCM cipher"
,
cipher
,
CIPHER_LEN
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
AES_GCM_CIPHER_CASE
,
cipher
,
CIPHER_LEN
);
free
(
nonce
);
free
(
cipher
);
}
#else // TEST_AES_GCM_ENCRYPT
{
LOGE
(
"no TEST_AES_GCM_ENCRYPT, do not test aesGcmEncrypt"
);
TEST_ASSERT_NULL
(
loader
->
aesGcmEncrypt
);
}
#endif // TEST_AES_GCM_ENCRYPT
static
void
TestAesGcmDecrypt
(
const
AlgLoader
*
loader
)
#if TEST_AES_GCM_DECRYPT
{
LOGI
(
"begin to test the AES-GCM algorithm decryption"
);
TEST_ASSERT_NOT_NULL
(
loader
->
aesGcmDecrypt
);
if
(
loader
->
aesGcmDecrypt
==
NULL
)
{
LOGE
(
"aesGcmDecrypt pointer is NULL! will not test!"
);
return
;
}
const
Uint8Buff
key
=
{
(
uint8_t
*
)
AES_GCM_TEST_KEY
,
AES_GCM_KEY_LEN
};
const
Uint8Buff
cipherBuffer
=
{
(
uint8_t
*
)
AES_GCM_CIPHER_CASE
,
CIPHER_LEN
};
uint8_t
*
nonce
=
(
uint8_t
*
)
malloc
(
NONCE_SIZE
);
TEST_ASSERT_NOT_NULL
(
nonce
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
nonce
,
NONCE_SIZE
,
0
,
NONCE_SIZE
));
GcmParam
gcmParams
;
gcmParams
.
aad
=
(
uint8_t
*
)
EXCHANGE_AAD
;
gcmParams
.
aadLen
=
(
uint32_t
)
strlen
(
EXCHANGE_AAD
);
gcmParams
.
nonce
=
nonce
;
gcmParams
.
nonceLen
=
NONCE_SIZE
;
uint8_t
*
plain
=
(
uint8_t
*
)
malloc
(
PLAIN_LEN
);
TEST_ASSERT_NOT_NULL
(
plain
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
plain
,
PLAIN_LEN
,
0
,
PLAIN_LEN
));
Uint8Buff
plainBuffer
=
{
plain
,
PLAIN_LEN
};
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
aesGcmDecrypt
(
&
key
,
&
cipherBuffer
,
&
gcmParams
,
false
,
&
plainBuffer
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
PrintBuffer
(
"AES-GCM plain"
,
plain
,
PLAIN_LEN
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
PLAIN_CASE
,
plain
,
PLAIN_LEN
);
free
(
nonce
);
free
(
plain
);
}
#else // TEST_AES_GCM_DECRYPT
{
LOGE
(
"no TEST_AES_GCM_DECRYPT, do not test aesGcmDecrypt"
);
TEST_ASSERT_NULL
(
loader
->
aesGcmDecrypt
);
}
#endif // TEST_AES_GCM_DECRYPT
static
void
TestHashToPoint
(
const
AlgLoader
*
loader
)
#if TEST_HASH_TO_POINT
{
TEST_ASSERT_NOT_NULL
(
loader
->
hashToPoint
);
if
(
loader
->
hashToPoint
==
NULL
)
{
LOGE
(
"hashToPoint pointer is NULL! will not test!"
);
return
;
}
const
Uint8Buff
hash
=
{
(
uint8_t
*
)
HASH_TO_POINT_CASE
,
SHA256_LEN
};
uint8_t
*
point
=
(
uint8_t
*
)
malloc
(
SHA256_LEN
);
TEST_ASSERT_NOT_NULL
(
point
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
point
,
SHA256_LEN
,
0
,
SHA256_LEN
));
Uint8Buff
pointBuffer
=
{
point
,
SHA256_LEN
};
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
hashToPoint
(
&
hash
,
X25519
,
&
pointBuffer
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
PrintBuffer
(
"hashToPoint"
,
point
,
SHA256_LEN
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
HASH_TO_POINT_RESULT
,
point
,
PLAIN_LEN
);
free
(
point
);
}
#else // TEST_HASH_TO_POINT
{
LOGE
(
"no TEST_HASH_TO_POINT, do not test loader->hashToPoint!"
);
TEST_ASSERT_NULL
(
loader
->
hashToPoint
);
}
#endif // TEST_HASH_TO_POINT
#if TEST_AGREE_SHARED_SECRET_WITH_STORAGE
static
void
VerifyAgreeSharedSecretWithStorage
(
const
AlgLoader
*
loader
,
const
Uint8Buff
*
key1
,
const
Uint8Buff
*
key2
)
{
const
Uint8Buff
keyInfo
=
{
(
uint8_t
*
)
HKDF_EXAMPLE_INFO
,
strlen
(
HKDF_EXAMPLE_INFO
)
};
const
Uint8Buff
salt
=
{
(
uint8_t
*
)
HKDF_EXAMPLE_SALT
,
sizeof
(
HKDF_EXAMPLE_SALT
)
};
Uint8Buff
outHkdf1
=
{
(
uint8_t
*
)
malloc
(
ED25519_KEY_BYTE_LEN
),
ED25519_KEY_BYTE_LEN
};
Uint8Buff
outHkdf2
=
{
(
uint8_t
*
)
malloc
(
ED25519_KEY_BYTE_LEN
),
ED25519_KEY_BYTE_LEN
};
TEST_ASSERT_NOT_NULL
(
outHkdf1
.
val
);
TEST_ASSERT_NOT_NULL
(
outHkdf2
.
val
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
outHkdf1
.
val
,
ED25519_KEY_BYTE_LEN
,
0
,
ED25519_KEY_BYTE_LEN
));
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
outHkdf2
.
val
,
ED25519_KEY_BYTE_LEN
,
0
,
ED25519_KEY_BYTE_LEN
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
computeHkdf
(
key1
,
&
salt
,
&
keyInfo
,
&
outHkdf1
,
true
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
computeHkdf
(
key2
,
&
salt
,
&
keyInfo
,
&
outHkdf2
,
true
));
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
outHkdf1
.
val
,
outHkdf2
.
val
,
ED25519_KEY_BYTE_LEN
);
free
(
outHkdf1
.
val
);
free
(
outHkdf2
.
val
);
}
static
int32_t
GenerateKeyPairWithStorage
(
const
AlgLoader
*
loader
,
const
Uint8Buff
*
keyAlias
)
{
const
ExtraInfo
extraInfo
=
{
.
authId
=
{
.
val
=
(
uint8_t
*
)
malloc
(
TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH
),
.
length
=
TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH
,
},
.
userType
=
DEVICE_TYPE_ACCESSORY
,
.
pairType
=
PAIR_TYPE_BIND
,
};
TEST_ASSERT_NOT_NULL
(
extraInfo
.
authId
.
val
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
extraInfo
.
authId
.
val
,
extraInfo
.
authId
.
length
,
0
,
extraInfo
.
authId
.
length
));
int32_t
ret
=
loader
->
generateKeyPairWithStorage
(
keyAlias
,
ED25519_KEY_BYTE_LEN
,
ED25519
,
&
extraInfo
);
free
(
extraInfo
.
authId
.
val
);
return
ret
;
}
static
void
TestAgreeSharedSecretWithStorage
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
agreeSharedSecretWithStorage
);
TEST_ASSERT_NOT_NULL
(
loader
->
computeHkdf
);
TEST_ASSERT_NOT_NULL
(
loader
->
generateKeyPairWithStorage
);
if
(
!
loader
->
agreeSharedSecretWithStorage
||
!
loader
->
computeHkdf
||
!
loader
->
generateKeyPairWithStorage
)
{
LOGE
(
"one of required function pointer is NULL! will not test!"
);
return
;
}
Uint8Buff
keyAliasA
=
{
(
uint8_t
*
)
KEY_PAIR_ALIAS_1
,
strlen
(
KEY_PAIR_ALIAS_1
)
};
Uint8Buff
keyAliasB
=
{
(
uint8_t
*
)
KEY_PAIR_ALIAS_2
,
strlen
(
KEY_PAIR_ALIAS_2
)
};
int
ret
;
ret
=
GenerateKeyPairWithStorage
(
loader
,
&
keyAliasA
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
ret
=
GenerateKeyPairWithStorage
(
loader
,
&
keyAliasB
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
if
(
ret
!=
HAL_SUCCESS
)
{
LOGE
(
"GenerateKeyPair failed! will not test!"
);
return
;
}
KeyBuff
keyA
=
{
keyAliasA
.
val
,
keyAliasA
.
length
,
true
};
KeyBuff
keyB
=
{
keyAliasB
.
val
,
keyAliasB
.
length
,
true
};
Uint8Buff
sharedKeyAlias1
=
{
(
uint8_t
*
)
SHARED_KEY_ALIAS_1
,
strlen
(
SHARED_KEY_ALIAS_1
)
};
Uint8Buff
sharedKeyAlias2
=
{
(
uint8_t
*
)
SHARED_KEY_ALIAS_2
,
strlen
(
SHARED_KEY_ALIAS_1
)
};
Algorithm
alg
=
ED25519
;
const
uint32_t
keyLength
=
ED25519_KEY_BYTE_LEN
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
agreeSharedSecretWithStorage
(
&
keyA
,
&
keyB
,
alg
,
keyLength
,
&
sharedKeyAlias1
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
agreeSharedSecretWithStorage
(
&
keyB
,
&
keyA
,
alg
,
keyLength
,
&
sharedKeyAlias2
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
VerifyAgreeSharedSecretWithStorage
(
loader
,
&
sharedKeyAlias1
,
&
sharedKeyAlias2
);
if
(
loader
->
deleteKey
)
{
LOGD
(
"test deleteKey"
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
sharedKeyAlias1
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
sharedKeyAlias2
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
keyAliasA
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
keyAliasB
));
}
}
#else // TEST_AGREE_SHARED_SECRET_WITH_STORAGE
static
void
TestAgreeSharedSecretWithStorage
(
const
AlgLoader
*
loader
)
{
LOGE
(
"no TEST_AGREE_SHARED_SECRET_WITH_STORAGE, do not test loader->agreeSharedSecretWithStorage!"
);
TEST_ASSERT_TRUE
(
loader
->
agreeSharedSecretWithStorage
==
NULL
||
loader
->
computeHkdf
==
NULL
||
loader
->
generateKeyPairWithStorage
==
NULL
);
LOG_ERROR_IF_POINTER_NULL
(
loader
->
agreeSharedSecretWithStorage
);
LOG_ERROR_IF_POINTER_NULL
(
loader
->
computeHkdf
);
LOG_ERROR_IF_POINTER_NULL
(
loader
->
generateKeyPairWithStorage
);
}
#endif // TEST_AGREE_SHARED_SECRET_WITH_STORAGE
static
void
TestAgreeSharedSecret
(
const
AlgLoader
*
loader
)
#if TEST_AGREE_SHARED_SECRET
{
TEST_ASSERT_NOT_NULL
(
loader
->
agreeSharedSecret
);
if
(
!
loader
->
agreeSharedSecret
)
{
LOGE
(
"agreeSharedSecret pointer is NULL! will not test!"
);
return
;
}
Algorithm
alg
=
X25519
;
const
uint32_t
keyLength
=
X25519_KEY_BYTE_LEN
;
KeyBuff
privateKeyA
=
{
(
uint8_t
*
)
X25519_PRIVATE_KEY_A
,
keyLength
,
false
};
KeyBuff
publicKeyA
=
{
(
uint8_t
*
)
X25519_PUBLIC_KEY_A
,
keyLength
,
false
};
KeyBuff
privateKeyB
=
{
(
uint8_t
*
)
X25519_PRIVATE_KEY_B
,
keyLength
,
false
};
KeyBuff
publicKeyB
=
{
(
uint8_t
*
)
X25519_PUBLIC_KEY_B
,
keyLength
,
false
};
Uint8Buff
sharedKey1
=
{
(
uint8_t
*
)
malloc
(
keyLength
),
keyLength
};
Uint8Buff
sharedKey2
=
{
(
uint8_t
*
)
malloc
(
keyLength
),
keyLength
};
TEST_ASSERT_NOT_NULL
(
sharedKey1
.
val
);
TEST_ASSERT_NOT_NULL
(
sharedKey2
.
val
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
sharedKey1
.
val
,
keyLength
,
0
,
keyLength
));
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
sharedKey2
.
val
,
keyLength
,
0
,
keyLength
));
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
agreeSharedSecret
(
&
privateKeyA
,
&
publicKeyB
,
alg
,
&
sharedKey1
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
agreeSharedSecret
(
&
privateKeyB
,
&
publicKeyA
,
alg
,
&
sharedKey2
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
PrintBuffer
(
"shared key 1"
,
sharedKey1
.
val
,
keyLength
);
PrintBuffer
(
"shared key 2"
,
sharedKey2
.
val
,
keyLength
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
sharedKey1
.
val
,
sharedKey2
.
val
,
ED25519_KEY_BYTE_LEN
);
free
(
sharedKey1
.
val
);
free
(
sharedKey2
.
val
);
}
#else // TEST_AGREE_SHARED_SECRET
{
LOGE
(
"no TEST_AGREE_SHARED_SECRET, do not test loader->agreeSharedSecret"
);
TEST_ASSERT_NULL
(
loader
->
agreeSharedSecret
);
}
#endif // TEST_AGREE_SHARED_SECRET
static
void
TestGenerateKeyPairWithStorage
(
const
AlgLoader
*
loader
)
#if TEST_GENERATE_KEY_PAIR_WITH_STORAGE
{
TEST_ASSERT_NOT_NULL
(
loader
->
generateKeyPairWithStorage
);
if
(
!
loader
->
generateKeyPairWithStorage
)
{
LOGE
(
"generateKeyPairWithStorage pointer is NULL! will not test!"
);
return
;
}
Uint8Buff
keyAlias
=
{
(
uint8_t
*
)
KEY_PAIR_ALIAS_1
,
strlen
(
KEY_PAIR_ALIAS_1
)
};
const
ExtraInfo
extraInfo
=
{
.
authId
=
{
.
val
=
(
uint8_t
*
)
malloc
(
TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH
),
.
length
=
TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH
,
},
.
userType
=
DEVICE_TYPE_ACCESSORY
,
.
pairType
=
PAIR_TYPE_BIND
,
};
TEST_ASSERT_NOT_NULL
(
extraInfo
.
authId
.
val
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
extraInfo
.
authId
.
val
,
extraInfo
.
authId
.
length
,
0
,
extraInfo
.
authId
.
length
));
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
generateKeyPairWithStorage
(
&
keyAlias
,
ED25519_KEY_BYTE_LEN
,
ED25519
,
&
extraInfo
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
if
(
loader
->
checkKeyExist
)
{
LOGD
(
"test checkKeyExist"
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
checkKeyExist
(
&
keyAlias
));
}
if
(
loader
->
deleteKey
)
{
LOGD
(
"test deleteKey"
);
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
keyAlias
));
}
free
(
extraInfo
.
authId
.
val
);
}
#else // TEST_GENERATE_KEY_PAIR_WITH_STORAGE
{
LOGE
(
"no TEST_GENERATE_KEY_PAIR_WITH_STORAGE, do not test loader->generateKeyPairWithStorage!"
);
TEST_ASSERT_NULL
(
loader
->
generateKeyPairWithStorage
);
}
#endif // TEST_GENERATE_KEY_PAIR_WITH_STORAGE
static
void
TestBigNumExpMod
(
const
AlgLoader
*
loader
)
#if TEST_BIG_NUM_EXP_MOD
{
TEST_ASSERT_NOT_NULL
(
loader
->
bigNumExpMod
);
if
(
loader
->
bigNumExpMod
==
NULL
)
{
LOGE
(
"bigNumExpMod pointer is NULL! will not test!"
);
return
;
}
for
(
uint32_t
i
=
0
;
i
<
ARRAY_SIZE
(
BIG_NUM_TEST_CASES
);
++
i
)
{
uint32_t
baseLength
=
BIG_NUM_TEST_CASES
[
i
].
baseLength
;
uint32_t
expLength
=
BIG_NUM_TEST_CASES
[
i
].
expLength
;
uint32_t
primeLength
=
strlen
(
BIG_NUM_TEST_CASES
[
i
].
prime
)
>>
1
;
const
Uint8Buff
base
=
{
(
uint8_t
*
)
BIG_NUM_TEST_CASES
[
i
].
base
,
baseLength
};
const
Uint8Buff
exp
=
{
(
uint8_t
*
)
BIG_NUM_TEST_CASES
[
i
].
exp
,
expLength
};
Uint8Buff
modResult
=
{
(
uint8_t
*
)
malloc
(
primeLength
),
primeLength
};
TEST_ASSERT_NOT_NULL
(
modResult
.
val
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
modResult
.
val
,
primeLength
,
0
,
primeLength
));
int
ret
;
LOGI
(
"test the big num case: base = %u, exp = %u, prime = %u"
,
baseLength
,
expLength
,
primeLength
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
loader
->
bigNumExpMod
(
&
base
,
&
exp
,
BIG_NUM_TEST_CASES
[
i
].
prime
,
&
modResult
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
ret
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
BIG_NUM_TEST_CASES
[
i
].
result
,
modResult
.
val
,
primeLength
);
PrintBuffer
(
"mod result"
,
modResult
.
val
,
modResult
.
length
);
free
(
modResult
.
val
);
}
}
#else // TEST_BIG_NUM_EXP_MOD
{
LOGE
(
"no TEST_BIG_NUM_EXP_MOD, do not test loader->bigNumExpMod!"
);
TEST_ASSERT_NULL
(
loader
->
bigNumExpMod
);
}
#endif // TEST_BIG_NUM_EXP_MOD
static
void
TestGenerateKeyPair
(
const
AlgLoader
*
loader
)
#if TEST_GENERATE_KEY_PAIR
{
TEST_ASSERT_NOT_NULL
(
loader
->
generateKeyPair
);
LOGE
(
"nobody use generateKeyPair, do not test"
);
}
#else // TEST_GENERATE_KEY_PAIR
{
TEST_ASSERT_NULL
(
loader
->
generateKeyPair
);
LOGE
(
"no TEST_GENERATE_KEY_PAIR, do not test generateKeyPair"
);
}
#endif // TEST_GENERATE_KEY_PAIR
#if (TEST_EXPORT_PUBLIC_KEY || TEST_IMPORT_PUBLIC_KEY || TEST_ALGORITHM_SIGN || TEST_ALGORITHM_VERIFY)
struct
TestExportImportSignVerifyParam
{
ExtraInfo
extInfo
;
Uint8Buff
keyAlias
;
Uint8Buff
outPubKey
;
Uint8Buff
anotherKeyAlias
;
Uint8Buff
messages
[
ARRAY_SIZE
(
TEST_SIGN_MSG_LENGTHES
)];
Uint8Buff
signatures
[
ARRAY_SIZE
(
TEST_SIGN_MSG_LENGTHES
)];
Uint8Buff
anotherOutPk
;
};
static
void
TestExportImportSignVerifyPrepareResources
(
struct
TestExportImportSignVerifyParam
*
param
)
{
param
->
extInfo
.
authId
.
length
=
TEST_EX_IM_SN_VF_EXTRA_INFO_AUTH_ID_LENGTH
;
param
->
extInfo
.
authId
.
val
=
(
uint8_t
*
)
malloc
(
param
->
extInfo
.
authId
.
length
);
param
->
extInfo
.
userType
=
DEVICE_TYPE_ACCESSORY
;
param
->
extInfo
.
pairType
=
PAIR_TYPE_BIND
;
TEST_ASSERT_NOT_NULL
(
param
->
extInfo
.
authId
.
val
);
FillRandom
(
param
->
extInfo
.
authId
.
val
,
param
->
extInfo
.
authId
.
length
,
param
->
extInfo
.
authId
.
length
);
param
->
keyAlias
.
length
=
TEST_EX_IM_SN_VF_KEY_ALIAS_LENGTH
;
param
->
keyAlias
.
val
=
(
uint8_t
*
)
malloc
(
param
->
keyAlias
.
length
);
TEST_ASSERT_NOT_NULL
(
param
->
keyAlias
.
val
);
FillRandom
(
param
->
keyAlias
.
val
,
param
->
keyAlias
.
length
,
param
->
keyAlias
.
length
);
param
->
outPubKey
.
length
=
TEST_EX_IM_SN_VF_OUT_PUB_KEY_LENGTH
;
param
->
outPubKey
.
val
=
(
uint8_t
*
)
malloc
(
param
->
outPubKey
.
length
);
TEST_ASSERT_NOT_NULL
(
param
->
outPubKey
.
val
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
param
->
outPubKey
.
val
,
param
->
outPubKey
.
length
,
0
,
param
->
outPubKey
.
length
));
param
->
anotherKeyAlias
.
length
=
TEST_EX_IM_SN_VF_KEY_ALIAS_LENGTH
;
param
->
anotherKeyAlias
.
val
=
(
uint8_t
*
)
malloc
(
param
->
anotherKeyAlias
.
length
);
TEST_ASSERT_NOT_NULL
(
param
->
anotherKeyAlias
.
val
);
do
{
FillRandom
(
param
->
anotherKeyAlias
.
val
,
param
->
anotherKeyAlias
.
length
,
param
->
anotherKeyAlias
.
length
);
}
while
(
memcmp
(
param
->
keyAlias
.
val
,
param
->
anotherKeyAlias
.
val
,
TEST_EX_IM_SN_VF_KEY_ALIAS_LENGTH
)
==
0
);
for
(
uint32_t
i
=
0
;
i
<
ARRAY_SIZE
(
TEST_SIGN_MSG_LENGTHES
);
++
i
)
{
param
->
messages
[
i
].
length
=
TEST_SIGN_MSG_LENGTHES
[
i
];
param
->
messages
[
i
].
val
=
(
uint8_t
*
)
malloc
(
param
->
messages
[
i
].
length
);
TEST_ASSERT_NOT_NULL
(
param
->
messages
[
i
].
val
);
FillRandom
(
param
->
messages
[
i
].
val
,
param
->
messages
[
i
].
length
,
param
->
messages
[
i
].
length
);
param
->
signatures
[
i
].
length
=
TEST_SIGN_SIGNATURE_LENGTH
;
param
->
signatures
[
i
].
val
=
(
uint8_t
*
)
malloc
(
param
->
signatures
[
i
].
length
);
TEST_ASSERT_NOT_NULL
(
param
->
signatures
[
i
].
val
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
param
->
signatures
[
i
].
val
,
param
->
signatures
[
i
].
length
,
0
,
param
->
signatures
[
i
].
length
));
}
param
->
anotherOutPk
.
length
=
TEST_EX_IM_SN_VF_OUT_PUB_KEY_LENGTH
;
param
->
anotherOutPk
.
val
=
(
uint8_t
*
)
malloc
(
param
->
anotherOutPk
.
length
);
TEST_ASSERT_NOT_NULL
(
param
->
anotherOutPk
.
val
);
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
param
->
anotherOutPk
.
val
,
param
->
anotherOutPk
.
length
,
0
,
param
->
anotherOutPk
.
length
));
}
static
void
TestExportImportSignVerifyInnerVerfiyNormalAndAbnormalCases
(
const
AlgLoader
*
loader
,
const
Algorithm
alg
,
struct
TestExportImportSignVerifyParam
*
param
)
{
int
res
;
for
(
uint32_t
i
=
0
;
i
<
ARRAY_SIZE
(
TEST_SIGN_MSG_LENGTHES
);
++
i
)
{
// test normal case
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
verify
(
&
param
->
anotherOutPk
,
&
param
->
messages
[
i
],
alg
,
&
param
->
signatures
[
i
],
false
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
// test tamper message
uint8_t
originMsg
=
param
->
messages
[
i
].
val
[
0
];
param
->
messages
[
i
].
val
[
0
]
=
((
originMsg
==
UINT8_MAX
)
?
0
:
(
originMsg
+
1
));
TEST_ASSERT_NOT_EQUAL
(
originMsg
,
param
->
messages
[
i
].
val
[
0
]);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
verify
(
&
param
->
anotherOutPk
,
&
param
->
messages
[
i
],
alg
,
&
param
->
signatures
[
i
],
false
));
TEST_ASSERT_NOT_EQUAL
(
HAL_SUCCESS
,
res
);
param
->
messages
[
i
].
val
[
0
]
=
originMsg
;
// test normal case
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
verify
(
&
param
->
anotherOutPk
,
&
param
->
messages
[
i
],
alg
,
&
param
->
signatures
[
i
],
false
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
// test tamper signature
uint8_t
originSig
=
param
->
signatures
[
i
].
val
[
0
];
param
->
signatures
[
i
].
val
[
0
]
=
((
originSig
==
UINT8_MAX
)
?
0
:
(
originSig
+
1
));
TEST_ASSERT_NOT_EQUAL
(
originSig
,
param
->
signatures
[
i
].
val
[
0
]);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
verify
(
&
param
->
anotherOutPk
,
&
param
->
messages
[
i
],
alg
,
&
param
->
signatures
[
i
],
false
));
TEST_ASSERT_NOT_EQUAL
(
HAL_SUCCESS
,
res
);
param
->
signatures
[
i
].
val
[
0
]
=
originSig
;
// test normal case
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
verify
(
&
param
->
anotherOutPk
,
&
param
->
messages
[
i
],
alg
,
&
param
->
signatures
[
i
],
false
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
}
}
static
void
TestExportImportSignVerifyInner
(
const
AlgLoader
*
loader
,
const
Algorithm
alg
,
struct
TestExportImportSignVerifyParam
*
param
)
{
int
res
;
// 1. generate one public private key pair
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
generateKeyPairWithStorage
(
&
param
->
keyAlias
,
TEST_EX_IM_SN_VF_KEY_LENGTH
,
alg
,
&
param
->
extInfo
));
// 2. export the public key which is generated in the first step
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
exportPublicKey
(
&
param
->
keyAlias
,
&
param
->
outPubKey
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
// 3. import the public key which is exported in the second step with a different name
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
importPublicKey
(
&
param
->
anotherKeyAlias
,
&
param
->
outPubKey
,
alg
,
&
param
->
extInfo
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
// 4. sign with the public key which is generated in the first step
for
(
uint32_t
i
=
0
;
i
<
ARRAY_SIZE
(
TEST_SIGN_MSG_LENGTHES
);
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
sign
(
&
param
->
keyAlias
,
&
param
->
messages
[
i
],
alg
,
&
param
->
signatures
[
i
],
true
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
TEST_ASSERT_GREATER_THAN
(
0u
,
param
->
signatures
[
i
].
length
);
TEST_ASSERT_LESS_OR_EQUAL
(
TEST_SIGN_SIGNATURE_LENGTH
,
param
->
signatures
[
i
].
length
);
TEST_ASSERT_NOT_EQUAL
(
param
->
signatures
[
i
].
length
,
CountZero
(
param
->
signatures
[
i
].
val
,
param
->
signatures
[
i
].
length
));
}
// 5. export the public key which is imported in the third step
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
exportPublicKey
(
&
param
->
anotherKeyAlias
,
&
param
->
anotherOutPk
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
// 6. verify the signature that is signed in the fourth step with the public key that is imported in the fifth step
TestExportImportSignVerifyInnerVerfiyNormalAndAbnormalCases
(
loader
,
alg
,
param
);
// 7. compare the public keys which are exported in the second and fifth step
PrintBuffer
(
"exported public key"
,
param
->
outPubKey
.
val
,
param
->
outPubKey
.
length
);
TEST_ASSERT_GREATER_THAN
(
0u
,
param
->
outPubKey
.
length
);
TEST_ASSERT_LESS_OR_EQUAL
(
TEST_EX_IM_SN_VF_OUT_PUB_KEY_LENGTH
,
param
->
outPubKey
.
length
);
TEST_ASSERT_NOT_EQUAL
(
param
->
outPubKey
.
length
,
CountZero
(
param
->
outPubKey
.
val
,
param
->
outPubKey
.
length
));
TEST_ASSERT_EQUAL_MESSAGE
(
param
->
outPubKey
.
length
,
param
->
anotherOutPk
.
length
,
TEST_EXPORT_DIFFERENT_ERROR_MESSAGE
);
TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE
(
param
->
outPubKey
.
val
,
param
->
anotherOutPk
.
val
,
param
->
outPubKey
.
length
,
TEST_EXPORT_DIFFERENT_ERROR_MESSAGE
);
if
(
loader
->
deleteKey
)
{
LOGD
(
"test deleteKey"
);
// 8. delete the key pair which is generated in the first step
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
param
->
keyAlias
));
// 9. delete the public key which is imported in the third step
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
loader
->
deleteKey
(
&
param
->
anotherKeyAlias
));
}
}
static
void
TestExportImportSignVerifyReleaseResources
(
struct
TestExportImportSignVerifyParam
*
param
)
{
free
(
param
->
extInfo
.
authId
.
val
);
param
->
extInfo
.
authId
.
val
=
NULL
;
free
(
param
->
keyAlias
.
val
);
param
->
keyAlias
.
val
=
NULL
;
free
(
param
->
outPubKey
.
val
);
param
->
outPubKey
.
val
=
NULL
;
free
(
param
->
anotherKeyAlias
.
val
);
param
->
anotherKeyAlias
.
val
=
NULL
;
for
(
uint32_t
i
=
0
;
i
<
ARRAY_SIZE
(
TEST_SIGN_MSG_LENGTHES
);
++
i
)
{
free
(
param
->
messages
[
i
].
val
);
param
->
messages
[
i
].
val
=
NULL
;
free
(
param
->
signatures
[
i
].
val
);
param
->
signatures
[
i
].
val
=
NULL
;
}
free
(
param
->
anotherOutPk
.
val
);
param
->
anotherOutPk
.
val
=
NULL
;
}
static
void
TestExportImportSignVerify
(
const
AlgLoader
*
loader
,
const
Algorithm
alg
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
generateKeyPairWithStorage
);
// only two test cases for exportPublicKey, P256 and ED25519, outKey length is 32
TEST_ASSERT_NOT_NULL
(
loader
->
exportPublicKey
);
TEST_ASSERT_NOT_NULL
(
loader
->
importPublicKey
);
// sign message length varies from min 1 to max 1024
TEST_ASSERT_NOT_NULL
(
loader
->
sign
);
TEST_ASSERT_NOT_NULL
(
loader
->
verify
);
TEST_ASSERT_TRUE
((
alg
==
ED25519
)
||
(
alg
==
P256
));
if
(((
alg
!=
ED25519
)
&&
(
alg
!=
P256
))
||
!
loader
->
generateKeyPairWithStorage
||
!
loader
->
exportPublicKey
||
!
loader
->
importPublicKey
||
!
loader
->
sign
||
!
loader
->
verify
)
{
LOGE
(
"one of requested pointer is NULL or alg is invalid, can not test!"
);
return
;
}
struct
TestExportImportSignVerifyParam
param
;
TestExportImportSignVerifyPrepareResources
(
&
param
);
TestExportImportSignVerifyInner
(
loader
,
alg
,
&
param
);
TestExportImportSignVerifyReleaseResources
(
&
param
);
}
static
void
TestExportImportSignVerifyP256AndEd25519
(
const
AlgLoader
*
loader
)
{
#if TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519
LOGI
(
"test export import sign verify ED25519"
);
TestExportImportSignVerify
(
loader
,
ED25519
);
#else // TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519
LOGE
(
"no TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519, do not test ED25519"
);
#endif // TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519
#if TEST_EXPORT_IMPORT_SIGN_VERIFY_P256
LOGI
(
"test export import sign verify P256"
);
TestExportImportSignVerify
(
loader
,
P256
);
#else // TEST_EXPORT_IMPORT_SIGN_VERIFY_P256
LOGE
(
"no TEST_EXPORT_IMPORT_SIGN_VERIFY_P256, do not test P256"
);
#endif // TEST_EXPORT_IMPORT_SIGN_VERIFY_P256
}
#endif // (TEST_EXPORT_PUBLIC_KEY || TEST_IMPORT_PUBLIC_KEY || TEST_ALGORITHM_SIGN || TEST_ALGORITHM_VERIFY)
static
void
TestExportPublicKey
(
const
AlgLoader
*
loader
)
#if TEST_EXPORT_PUBLIC_KEY
{
TEST_ASSERT_NOT_NULL
(
loader
->
exportPublicKey
);
if
(
!
loader
->
exportPublicKey
)
{
LOGE
(
"exportPublicKey pointer is NULL, can not test!"
);
return
;
}
TestExportImportSignVerifyP256AndEd25519
(
loader
);
}
#else // TEST_EXPORT_PUBLIC_KEY
{
TEST_ASSERT_NULL
(
loader
->
exportPublicKey
);
LOGE
(
"no TEST_EXPORT_PUBLIC_KEY, do not test exportPublicKey"
);
}
#endif // TEST_EXPORT_PUBLIC_KEY
static
void
TestSign
(
const
AlgLoader
*
loader
)
#if TEST_ALGORITHM_SIGN
{
TEST_ASSERT_NOT_NULL
(
loader
->
sign
);
if
(
!
loader
->
sign
)
{
LOGE
(
"sign pointer is NULL, can not test!"
);
return
;
}
TestExportImportSignVerifyP256AndEd25519
(
loader
);
}
#else // TEST_ALGORITHM_SIGN
{
TEST_ASSERT_NULL
(
loader
->
sign
);
LOGE
(
"no TEST_ALGORITHM_SIGN, do not test sign"
);
}
#endif // TEST_ALGORITHM_SIGN
static
void
TestVerify
(
const
AlgLoader
*
loader
)
#if TEST_ALGORITHM_VERIFY
{
TEST_ASSERT_NOT_NULL
(
loader
->
verify
);
if
(
!
loader
->
verify
)
{
LOGE
(
"verify pointer is NULL, can not test!"
);
return
;
}
TestExportImportSignVerifyP256AndEd25519
(
loader
);
}
#else // TEST_ALGORITHM_VERIFY
{
TEST_ASSERT_NULL
(
loader
->
verify
);
LOGE
(
"no TEST_ALGORITHM_VERIFY, do not test verify"
);
}
#endif // TEST_ALGORITHM_VERIFY
static
void
TestImportPublicKey
(
const
AlgLoader
*
loader
)
#if TEST_IMPORT_PUBLIC_KEY
{
TEST_ASSERT_NOT_NULL
(
loader
->
importPublicKey
);
if
(
!
loader
->
importPublicKey
)
{
LOGE
(
"importPublicKey pointer is NULL, can not test!"
);
return
;
}
TestExportImportSignVerifyP256AndEd25519
(
loader
);
}
#else // TEST_IMPORT_PUBLIC_KEY
{
TEST_ASSERT_NULL
(
loader
->
importPublicKey
);
LOGE
(
"no TEST_IMPORT_PUBLIC_KEY, do not test importPublicKey"
);
}
#endif // TEST_IMPORT_PUBLIC_KEY
#if TEST_CHECK_DL_PUBLIC_KEY // {
static
void
TestCheckDlPublicKeyInner
(
const
AlgLoader
*
loader
,
Uint8Buff
*
key
,
const
char
*
primeHex
)
{
bool
res
;
int
randIndex
;
// 1. all zero
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
key
->
val
,
key
->
length
,
0
,
key
->
length
));
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkDlPublicKey
(
key
,
primeHex
));
TEST_ASSERT_EQUAL
(
false
,
res
);
// 2. value is 1
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
key
->
val
,
key
->
length
,
0
,
key
->
length
));
key
->
val
[
key
->
length
-
1
]
=
TEST_CHECK_DL_VALUE_ONE
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkDlPublicKey
(
key
,
primeHex
));
TEST_ASSERT_EQUAL
(
false
,
res
);
// 3. value is 2
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
key
->
val
,
key
->
length
,
0
,
key
->
length
));
key
->
val
[
key
->
length
-
1
]
=
TEST_CHECK_DL_VALUE_TWO
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkDlPublicKey
(
key
,
primeHex
));
TEST_ASSERT_EQUAL
(
true
,
res
);
// 4. value is between 2 and primeHex - 2
// first, init value with 2
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
key
->
val
,
key
->
length
,
0
,
key
->
length
));
key
->
val
[
key
->
length
-
1
]
=
TEST_CHECK_DL_VALUE_TWO
;
// then add 1 on rand byte
randIndex
=
rand
()
%
key
->
length
;
key
->
val
[
randIndex
]
+=
TEST_CHECK_DL_VALUE_ONE
;
PrintBuffer
(
"rand key"
,
key
->
val
,
key
->
length
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkDlPublicKey
(
key
,
primeHex
));
TEST_ASSERT_EQUAL
(
true
,
res
);
// first, init value with primeHex - 2
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
key
->
val
,
key
->
length
,
0
,
key
->
length
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
HexStringToByte
(
primeHex
,
key
->
val
,
key
->
length
));
TEST_ASSERT_GREATER_OR_EQUAL
(
TEST_CHECK_DL_VALUE_TWO
,
key
->
val
[
key
->
length
-
1
]);
key
->
val
[
key
->
length
-
1
]
-=
TEST_CHECK_DL_VALUE_TWO
;
// then sub 1 on rand byte
do
{
randIndex
=
rand
()
%
key
->
length
;
}
while
(
key
->
val
[
randIndex
]
<
TEST_CHECK_DL_VALUE_ONE
);
key
->
val
[
randIndex
]
-=
TEST_CHECK_DL_VALUE_ONE
;
PrintBuffer
(
"rand key"
,
key
->
val
,
key
->
length
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkDlPublicKey
(
key
,
primeHex
));
TEST_ASSERT_EQUAL
(
true
,
res
);
// 5. value is primeHex - 2
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
key
->
val
,
key
->
length
,
0
,
key
->
length
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
HexStringToByte
(
primeHex
,
key
->
val
,
key
->
length
));
TEST_ASSERT_GREATER_OR_EQUAL
(
TEST_CHECK_DL_VALUE_TWO
,
key
->
val
[
key
->
length
-
1
]);
key
->
val
[
key
->
length
-
1
]
-=
TEST_CHECK_DL_VALUE_TWO
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkDlPublicKey
(
key
,
primeHex
));
TEST_ASSERT_EQUAL
(
true
,
res
);
// 6. value is primeHex - 1
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
key
->
val
,
key
->
length
,
0
,
key
->
length
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
HexStringToByte
(
primeHex
,
key
->
val
,
key
->
length
));
TEST_ASSERT_GREATER_OR_EQUAL
(
TEST_CHECK_DL_VALUE_ONE
,
key
->
val
[
key
->
length
-
1
]);
key
->
val
[
key
->
length
-
1
]
-=
TEST_CHECK_DL_VALUE_ONE
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkDlPublicKey
(
key
,
primeHex
));
TEST_ASSERT_EQUAL
(
false
,
res
);
// 7. value is primeHex
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
key
->
val
,
key
->
length
,
0
,
key
->
length
));
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
HexStringToByte
(
primeHex
,
key
->
val
,
key
->
length
));
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
checkDlPublicKey
(
key
,
primeHex
));
TEST_ASSERT_EQUAL
(
false
,
res
);
}
static
void
TestCheckDlPublicKey
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
checkDlPublicKey
);
if
(
!
loader
->
checkDlPublicKey
)
{
LOGE
(
"checkDlPublicKey pointer is NULL, can not test!"
);
return
;
}
Uint8Buff
key
;
key
.
length
=
PAKE_DL_PRIME_LEN_256
;
key
.
val
=
(
uint8_t
*
)
malloc
(
key
.
length
);
TEST_ASSERT_NOT_NULL
(
key
.
val
);
TestCheckDlPublicKeyInner
(
loader
,
&
key
,
LARGE_PRIME_NUM_HEX_256
);
free
(
key
.
val
);
key
.
length
=
PAKE_DL_PRIME_LEN_384
;
key
.
val
=
(
uint8_t
*
)
malloc
(
key
.
length
);
TEST_ASSERT_NOT_NULL
(
key
.
val
);
TestCheckDlPublicKeyInner
(
loader
,
&
key
,
LARGE_PRIME_NUM_HEX_384
);
free
(
key
.
val
);
}
#else // TEST_CHECK_DL_PUBLIC_KEY // } {
static
void
TestCheckDlPublicKey
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NULL
(
loader
->
checkDlPublicKey
);
LOGE
(
"no TEST_CHECK_DL_PUBLIC_KEY, do not test checkDlPublicKey"
);
}
#endif // TEST_CHECK_DL_PUBLIC_KEY // }
static
void
TestCheckEcPublicKey
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NULL
(
loader
->
checkEcPublicKey
);
LOGE
(
"loader->checkEcPublicKey is NULL, and nobody use it, do not test!"
);
}
#if TEST_BIG_NUM_COMPARE // {
static
void
TestBigNumCompareInnerMinMax
(
const
AlgLoader
*
loader
,
Uint8Buff
*
x
,
Uint8Buff
*
y
)
{
// 0. 0xFFFFFF > 0x000000
int
res
;
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
x
->
val
,
x
->
length
,
UINT8_MAX
,
x
->
length
));
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
y
->
val
,
y
->
length
,
0
,
y
->
length
));
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
x
,
y
));
TEST_ASSERT_EQUAL
(
1
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
y
,
x
));
TEST_ASSERT_EQUAL
(
-
1
,
res
);
}
static
void
TestBigNumCompareInnerFull
(
const
AlgLoader
*
loader
,
Uint8Buff
*
x
,
Uint8Buff
*
y
)
{
int
previous
,
res
;
// 1. 0x123456 > 0x123455
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
x
->
val
,
x
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
)));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
y
->
val
,
y
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
)));
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
x
->
val
,
y
->
val
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
);
previous
=
y
->
val
[
y
->
length
-
1
];
y
->
val
[
y
->
length
-
1
]
-=
1
;
TEST_ASSERT_LESS_THAN
(
previous
,
y
->
val
[
y
->
length
-
1
]);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
x
,
y
));
TEST_ASSERT_EQUAL
(
1
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
y
,
x
));
TEST_ASSERT_EQUAL
(
-
1
,
res
);
// 2. 0x123456 = 0x123456
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
x
->
val
,
x
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
)));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
y
->
val
,
y
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
)));
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
x
->
val
,
y
->
val
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
x
,
y
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
y
,
x
));
TEST_ASSERT_EQUAL
(
0
,
res
);
// 3. 0x123456 < 0x123457
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
x
->
val
,
x
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
)));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
y
->
val
,
y
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
)));
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
x
->
val
,
y
->
val
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
);
previous
=
y
->
val
[
y
->
length
-
1
];
y
->
val
[
y
->
length
-
1
]
+=
1
;
TEST_ASSERT_GREATER_THAN
(
previous
,
y
->
val
[
y
->
length
-
1
]);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
x
,
y
));
TEST_ASSERT_EQUAL
(
-
1
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
y
,
x
));
TEST_ASSERT_EQUAL
(
1
,
res
);
}
static
void
TestBigNumCompareInnerHalf
(
const
AlgLoader
*
loader
,
Uint8Buff
*
x
,
Uint8Buff
*
y
)
{
int
previous
,
res
;
// 4. 0x003456 > 0x3455
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
x
->
val
,
x
->
length
,
0
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
x
->
val
+
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
x
->
length
-
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
y
->
val
,
y
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
x
->
val
+
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
y
->
val
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
);
previous
=
y
->
val
[
y
->
length
-
1
];
y
->
val
[
y
->
length
-
1
]
-=
1
;
TEST_ASSERT_LESS_THAN
(
previous
,
y
->
val
[
y
->
length
-
1
]);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
x
,
y
));
TEST_ASSERT_EQUAL
(
1
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
y
,
x
));
TEST_ASSERT_EQUAL
(
-
1
,
res
);
// 5. 0x003456 = 0x3456
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
x
->
val
,
x
->
length
,
0
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
x
->
val
+
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
x
->
length
-
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
y
->
val
,
y
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
x
->
val
+
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
y
->
val
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
x
,
y
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
y
,
x
));
TEST_ASSERT_EQUAL
(
0
,
res
);
// 6. 0x003456 < 0x3457
TEST_ASSERT_EQUAL
(
EOK
,
memset_s
(
x
->
val
,
x
->
length
,
0
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
x
->
val
+
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
x
->
length
-
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
y
->
val
,
y
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
x
->
val
+
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
y
->
val
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
);
previous
=
y
->
val
[
y
->
length
-
1
];
y
->
val
[
y
->
length
-
1
]
+=
1
;
TEST_ASSERT_GREATER_THAN
(
previous
,
y
->
val
[
y
->
length
-
1
]);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
x
,
y
));
TEST_ASSERT_EQUAL
(
-
1
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
y
,
x
));
TEST_ASSERT_EQUAL
(
1
,
res
);
}
static
void
TestBigNumCompareInnerCompareFullAgainstHalf
(
const
AlgLoader
*
loader
,
Uint8Buff
*
x
,
Uint8Buff
*
y
)
{
int
res
;
// 7. 0x123456 > 0x3456
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
x
->
val
,
x
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
x
->
val
+
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
x
->
length
-
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL
(
EOK
,
memcpy_s
(
y
->
val
,
y
->
length
,
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
,
sizeof
(
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
)));
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
x
->
val
+
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
,
y
->
val
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
x
,
y
));
TEST_ASSERT_EQUAL
(
1
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
bigNumCompare
(
y
,
x
));
TEST_ASSERT_EQUAL
(
-
1
,
res
);
}
static
void
TestBigNumCompare
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NOT_NULL
(
loader
->
bigNumCompare
);
if
(
!
loader
->
bigNumCompare
)
{
LOGE
(
"bigNumCompare pointer is NULL, can not test!"
);
return
;
}
Uint8Buff
x
=
{
(
uint8_t
*
)
malloc
(
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
),
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
};
TEST_ASSERT_NOT_NULL
(
x
.
val
);
Uint8Buff
y
=
{
(
uint8_t
*
)
malloc
(
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
),
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
};
TEST_ASSERT_NOT_NULL
(
y
.
val
);
TestBigNumCompareInnerMinMax
(
loader
,
&
x
,
&
y
);
TestBigNumCompareInnerFull
(
loader
,
&
x
,
&
y
);
free
(
y
.
val
);
y
.
length
=
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
;
y
.
val
=
(
uint8_t
*
)
malloc
(
y
.
length
);
TEST_ASSERT_NOT_NULL
(
y
.
val
);
TestBigNumCompareInnerHalf
(
loader
,
&
x
,
&
y
);
TestBigNumCompareInnerCompareFullAgainstHalf
(
loader
,
&
x
,
&
y
);
free
(
x
.
val
);
free
(
y
.
val
);
}
#else // TEST_BIG_NUM_COMPARE // } {
static
void
TestBigNumCompare
(
const
AlgLoader
*
loader
)
{
TEST_ASSERT_NULL
(
loader
->
bigNumCompare
);
LOGE
(
"no TEST_BIG_NUM_COMPARE, do not test loader->bigNumCompare"
);
}
#endif // TEST_BIG_NUM_COMPARE // {
void
TestHcAlg
(
void
)
{
const
AlgLoader
*
loader
=
GetLoaderInstance
();
TEST_ASSERT_NOT_NULL
(
loader
);
if
(
loader
==
NULL
)
{
LOGE
(
"alg loader instance is NULL"
);
return
;
}
int32_t
res
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
loader
->
initAlg
());
TEST_ASSERT_EQUAL
(
HAL_SUCCESS
,
res
);
TestSha256
(
loader
);
TestGenerateRandom
(
loader
);
TestComputeHmac
(
loader
);
TestComputeHkdf
(
loader
);
#if (defined(DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY) && DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY)
(
void
)(
TestImportSymmetricKey
);
#else // DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY
TestImportSymmetricKey
(
loader
);
#endif // DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY
TestCheckKeyExist
(
loader
);
TestDeleteKey
(
loader
);
TestAesGcmEncrypt
(
loader
);
TestAesGcmDecrypt
(
loader
);
TestHashToPoint
(
loader
);
TestGenerateKeyPairWithStorage
(
loader
);
TestAgreeSharedSecretWithStorage
(
loader
);
TestAgreeSharedSecret
(
loader
);
TestBigNumExpMod
(
loader
);
TestGenerateKeyPair
(
loader
);
TestExportPublicKey
(
loader
);
TestSign
(
loader
);
TestVerify
(
loader
);
TestImportPublicKey
(
loader
);
TestCheckDlPublicKey
(
loader
);
TestCheckEcPublicKey
(
loader
);
TestBigNumCompare
(
loader
);
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_alg_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_ALG_TEST_H
#define HC_ALG_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcAlg
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_ALG_TEST_H
security_lite/deviceauth_basic_deps/hc_alg_test_case.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_ALG_TEST_CASE_H
#define HC_ALG_TEST_CASE_H
#include <ohos_types.h> // ARRAY_SIZE
#include <stdint.h>
#ifdef __cplusplus
extern
"C"
{
#endif
#define KEY_PAIR_ALIAS_1 "test: key pair 1"
#define KEY_PAIR_ALIAS_2 "test: key pair 2"
#define SHARED_KEY_ALIAS_1 "test: shared key 1"
#define SHARED_KEY_ALIAS_2 "test: shared key 2"
#define EXCHANGE_AAD "hichain_iso_exchange"
enum
{
NONCE_SIZE
=
12
,
AES_GCM_KEY_LEN
=
128
/
8
,
TAG_LEN
=
16
,
CIPHER_LEN
=
32
,
PLAIN_LEN
=
16
,
X25519_KEY_BYTE_LEN
=
32
,
ED25519_KEY_BYTE_LEN
=
32
,
};
typedef
struct
{
uint32_t
baseLength
;
uint32_t
expLength
;
const
char
*
prime
;
const
uint8_t
*
base
;
const
uint8_t
*
exp
;
const
uint8_t
*
result
;
}
BigNumTestCase
;
static
const
uint8_t
AES_GCM_TEST_KEY
[
AES_GCM_KEY_LEN
]
=
{
0xc7
,
0x4f
,
0x98
,
0x27
,
0x09
,
0xcf
,
0xbe
,
0x04
,
0x03
,
0x81
,
0xbc
,
0x4a
,
0x45
,
0xed
,
0xe9
,
0xcb
};
static
const
uint8_t
AES_GCM_CIPHER_CASE
[
CIPHER_LEN
]
=
{
0xf0
,
0x1f
,
0x08
,
0xb2
,
0xb1
,
0x79
,
0xc9
,
0x65
,
0xc6
,
0x45
,
0x0c
,
0xc9
,
0xb9
,
0xb6
,
0x07
,
0xc0
,
0x27
,
0x0c
,
0x8d
,
0xa0
,
0x33
,
0x6a
,
0x5b
,
0xa9
,
0x0f
,
0x1a
,
0x01
,
0xde
,
0x43
,
0xda
,
0x79
,
0x7f
};
static
const
uint8_t
PLAIN_CASE
[]
=
"This is the case"
;
static
const
uint8_t
HASH_TO_POINT_CASE
[]
=
{
0x75
,
0x6d
,
0xee
,
0x8b
,
0xa1
,
0xce
,
0xce
,
0xa3
,
0x1e
,
0x68
,
0x02
,
0xe8
,
0xe4
,
0xbe
,
0xe0
,
0x9e
,
0x3b
,
0x01
,
0xfa
,
0xe0
,
0x34
,
0x77
,
0x65
,
0x2c
,
0xf0
,
0x2F
,
0x33
,
0x7a
,
0x54
,
0x6b
,
0xd9
,
0xdd
};
static
const
uint8_t
HASH_TO_POINT_RESULT
[]
=
{
0xd4
,
0xa8
,
0x7e
,
0xa6
,
0xd7
,
0x07
,
0xb0
,
0xea
,
0xef
,
0x28
,
0xd8
,
0x98
,
0x89
,
0xcc
,
0xa0
,
0xd8
,
0x65
,
0x4d
,
0x8e
,
0xdd
,
0x4b
,
0x16
,
0x7a
,
0x0d
,
0xde
,
0x4f
,
0xf2
,
0x99
,
0xd3
,
0x4c
,
0xb4
,
0x45
};
static
const
uint8_t
X25519_PRIVATE_KEY_A
[
X25519_KEY_BYTE_LEN
]
=
{
0x6c
,
0xe7
,
0xf5
,
0x5c
,
0x2d
,
0xc8
,
0x89
,
0x6b
,
0xfc
,
0x64
,
0xe8
,
0xc4
,
0x58
,
0xfe
,
0xbe
,
0x13
,
0x45
,
0x01
,
0xa4
,
0x7a
,
0xa1
,
0x60
,
0xcd
,
0x4c
,
0xaa
,
0x7b
,
0x19
,
0x10
,
0x23
,
0x33
,
0xa1
,
0x32
};
static
const
uint8_t
X25519_PUBLIC_KEY_A
[
X25519_KEY_BYTE_LEN
]
=
{
0x10
,
0x65
,
0x4b
,
0x65
,
0xf9
,
0x40
,
0x10
,
0x20
,
0x4b
,
0x2f
,
0xff
,
0xc6
,
0xaf
,
0xb3
,
0xa8
,
0x86
,
0x69
,
0xda
,
0x32
,
0xf4
,
0xa7
,
0x00
,
0x37
,
0x82
,
0x7e
,
0xd3
,
0x39
,
0xd1
,
0x02
,
0x2b
,
0x23
,
0x5d
};
static
const
uint8_t
X25519_PRIVATE_KEY_B
[
X25519_KEY_BYTE_LEN
]
=
{
0xc3
,
0xb2
,
0xc7
,
0xc3
,
0x1c
,
0x7e
,
0xad
,
0x20
,
0x5f
,
0x00
,
0xdf
,
0x1a
,
0xe0
,
0xe6
,
0x9e
,
0x6c
,
0xf8
,
0xac
,
0x2f
,
0xd5
,
0xea
,
0xa5
,
0xb6
,
0xe7
,
0x75
,
0x46
,
0xcb
,
0x85
,
0xbc
,
0x0e
,
0x68
,
0xb6
};
static
const
uint8_t
X25519_PUBLIC_KEY_B
[
X25519_KEY_BYTE_LEN
]
=
{
0xd7
,
0x7b
,
0xa7
,
0x19
,
0x8b
,
0x3e
,
0x54
,
0x4c
,
0xc3
,
0x45
,
0xb9
,
0x61
,
0xa0
,
0x9c
,
0x23
,
0xfc
,
0xeb
,
0x1f
,
0x9c
,
0x30
,
0x0f
,
0x3c
,
0xcd
,
0x17
,
0x7d
,
0xdc
,
0x50
,
0x0f
,
0x40
,
0x03
,
0x90
,
0x2e
};
static
const
char
PRIME_HEX_384
[]
=
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74"
"020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437"
"4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
"EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF05"
"98DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB"
"9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
"E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
"3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33"
"A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
"ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864"
"D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E2"
"08E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF"
;
static
const
char
PRIME_HEX_256
[]
=
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74"
"020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437"
"4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
"EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF05"
"98DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB"
"9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
"E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
"3995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF"
;
static
const
uint8_t
BASE_HEX_32
[]
=
{
0x42
,
0x6B
,
0x93
,
0xAA
,
0x93
,
0x27
,
0xD7
,
0x43
,
0x8A
,
0x92
,
0x67
,
0x77
,
0x77
,
0x23
,
0x51
,
0xAA
,
0xD5
,
0xCF
,
0xA3
,
0xDB
,
0x53
,
0x0B
,
0x81
,
0x77
,
0x85
,
0x85
,
0xCC
,
0x83
,
0x50
,
0x41
,
0x38
,
0xE3
};
static
const
uint8_t
BASE_HEX_256
[]
=
{
0xDA
,
0xC2
,
0xE1
,
0x78
,
0x68
,
0xD7
,
0x3E
,
0x0E
,
0xB2
,
0x1A
,
0x33
,
0xA9
,
0x1F
,
0x0C
,
0xD2
,
0x44
,
0x75
,
0xEC
,
0xDC
,
0xF3
,
0x47
,
0x7B
,
0xEF
,
0x7D
,
0x22
,
0x01
,
0x94
,
0x34
,
0x01
,
0x8F
,
0x9A
,
0x57
,
0xC1
,
0x04
,
0xFE
,
0x09
,
0x9C
,
0xB1
,
0x50
,
0xF5
,
0xDD
,
0x09
,
0x08
,
0x3E
,
0x08
,
0x9E
,
0xD3
,
0x13
,
0x62
,
0x91
,
0xC7
,
0x72
,
0x9B
,
0x1F
,
0x1F
,
0x6A
,
0x0A
,
0x26
,
0xD6
,
0xF7
,
0xEE
,
0xFC
,
0x3C
,
0x35
,
0x90
,
0x94
,
0xF0
,
0x7B
,
0xEF
,
0x59
,
0xE3
,
0xF2
,
0x0D
,
0x2B
,
0x47
,
0xAB
,
0x8D
,
0xB2
,
0xA4
,
0xFD
,
0x0D
,
0x68
,
0x9E
,
0xA4
,
0xCF
,
0xE2
,
0x7D
,
0x19
,
0x74
,
0x91
,
0x7D
,
0x18
,
0xFB
,
0x81
,
0x89
,
0xC4
,
0xCA
,
0x49
,
0x31
,
0xC3
,
0xFB
,
0xE5
,
0x6C
,
0x43
,
0x9A
,
0x5B
,
0x56
,
0xF1
,
0xBB
,
0xE7
,
0xF0
,
0x76
,
0x66
,
0x3E
,
0x06
,
0x4B
,
0x53
,
0x01
,
0x38
,
0x28
,
0xA6
,
0xB6
,
0x27
,
0x50
,
0xAB
,
0x00
,
0x20
,
0x54
,
0x84
,
0x6F
,
0x08
,
0xCB
,
0x13
,
0xC3
,
0x5D
,
0x24
,
0x27
,
0x02
,
0x5C
,
0x0F
,
0x90
,
0xA5
,
0xA0
,
0x1E
,
0xDC
,
0xF9
,
0xE5
,
0x2F
,
0xCB
,
0x53
,
0xBC
,
0xD9
,
0x10
,
0x52
,
0xF6
,
0x45
,
0x73
,
0x21
,
0x7B
,
0x53
,
0x12
,
0xBD
,
0xF3
,
0x05
,
0xDA
,
0xE2
,
0x1B
,
0x65
,
0x70
,
0x62
,
0x74
,
0x68
,
0xCB
,
0x1C
,
0xEE
,
0xFD
,
0xF9
,
0xFC
,
0x83
,
0x95
,
0x7C
,
0xB5
,
0xCF
,
0xCE
,
0x83
,
0x7B
,
0xBA
,
0x4D
,
0xEC
,
0xA9
,
0xDF
,
0x6D
,
0xF1
,
0x85
,
0x59
,
0x14
,
0xB7
,
0x94
,
0x46
,
0x57
,
0x44
,
0x10
,
0x4E
,
0x6E
,
0xC5
,
0x68
,
0xDA
,
0x82
,
0x92
,
0x5A
,
0xDB
,
0x89
,
0x5D
,
0x3B
,
0x5E
,
0xB3
,
0x24
,
0xB4
,
0x55
,
0x4A
,
0xE9
,
0x41
,
0xCB
,
0xC6
,
0xE3
,
0xFE
,
0xC3
,
0xAD
,
0x2F
,
0xB3
,
0xA6
,
0x0F
,
0x7D
,
0x4C
,
0xA5
,
0xED
,
0x95
,
0x70
,
0x97
,
0x12
,
0x54
,
0xAB
,
0x58
,
0x0E
,
0xE5
,
0xF6
,
0x8B
,
0x37
,
0x0B
,
0x7C
,
0x06
,
0x54
,
0x89
,
0xDD
,
0x8A
,
0xA9
};
static
const
uint8_t
EXP_HEX_1
[]
=
{
0xE9
};
static
const
uint8_t
EXP_HEX_28
[]
=
{
0x8F
,
0x6F
,
0xC2
,
0xC0
,
0x64
,
0x37
,
0x1E
,
0x98
,
0x71
,
0xC9
,
0xF5
,
0x5E
,
0x45
,
0x5F
,
0x46
,
0x61
,
0x1B
,
0x4D
,
0x7D
,
0x23
,
0x21
,
0x01
,
0x1C
,
0x56
,
0xE2
,
0x77
,
0x14
,
0x64
};
static
const
uint8_t
EXP_HEX_32
[]
=
{
0xA9
,
0xC9
,
0x9A
,
0x5B
,
0xB5
,
0x9F
,
0xC6
,
0x9E
,
0xE3
,
0xF7
,
0x4B
,
0xFC
,
0xDC
,
0xF4
,
0x26
,
0x20
,
0xBE
,
0xAF
,
0x03
,
0x17
,
0xEC
,
0x56
,
0x2C
,
0xB5
,
0x46
,
0x13
,
0x33
,
0xD6
,
0x97
,
0x6A
,
0x33
,
0x7C
};
static
const
uint8_t
BASE_HEX_384
[]
=
{
0x37
,
0xBE
,
0xDE
,
0x74
,
0x1B
,
0x5D
,
0x7D
,
0x58
,
0x86
,
0x55
,
0xD3
,
0xCB
,
0x52
,
0x2A
,
0x6C
,
0x11
,
0xB5
,
0x97
,
0x68
,
0x26
,
0x21
,
0x68
,
0x62
,
0x51
,
0x6E
,
0xFA
,
0x0B
,
0x44
,
0x04
,
0x18
,
0x92
,
0xD9
,
0x11
,
0xB0
,
0x33
,
0x58
,
0x46
,
0xCD
,
0x8B
,
0x8E
,
0x46
,
0x24
,
0x25
,
0xFE
,
0x58
,
0xD9
,
0x9D
,
0xC4
,
0x1B
,
0xA2
,
0x17
,
0x5D
,
0xA5
,
0x76
,
0xA9
,
0x81
,
0x93
,
0x49
,
0x1A
,
0xB8
,
0x2D
,
0x29
,
0xDA
,
0xE5
,
0x29
,
0x5F
,
0xE3
,
0x85
,
0x09
,
0xE4
,
0xC6
,
0xF2
,
0x73
,
0x65
,
0x40
,
0xBA
,
0x93
,
0xAA
,
0x08
,
0x43
,
0xB8
,
0x07
,
0xF7
,
0x01
,
0xA5
,
0xFB
,
0x1E
,
0x85
,
0xBB
,
0x14
,
0x3C
,
0x2B
,
0xA8
,
0x4D
,
0xD8
,
0x3C
,
0xA3
,
0x19
,
0x16
,
0x86
,
0x55
,
0xE2
,
0xFC
,
0xC0
,
0xA0
,
0xA0
,
0x69
,
0x07
,
0x6A
,
0x04
,
0xBA
,
0x76
,
0xC4
,
0x60
,
0xFE
,
0xCB
,
0xA8
,
0x50
,
0x26
,
0x40
,
0xAB
,
0x86
,
0x90
,
0xBA
,
0x23
,
0xDC
,
0x06
,
0xA3
,
0xFE
,
0xE2
,
0x21
,
0x2C
,
0xB8
,
0x3B
,
0xF8
,
0x02
,
0xFB
,
0x1E
,
0x2A
,
0xBA
,
0xA7
,
0x60
,
0x5D
,
0x12
,
0xE6
,
0xE7
,
0xC1
,
0xA3
,
0x14
,
0x53
,
0x42
,
0x50
,
0x52
,
0x10
,
0x20
,
0xC2
,
0x7C
,
0x9B
,
0xE6
,
0xE7
,
0xD0
,
0x3B
,
0x31
,
0x2D
,
0x4B
,
0xFA
,
0x70
,
0x3B
,
0x32
,
0x19
,
0x32
,
0x71
,
0x34
,
0xFE
,
0x12
,
0x0D
,
0xE4
,
0x03
,
0x1D
,
0x95
,
0xAD
,
0xBC
,
0xEB
,
0x86
,
0xE2
,
0x72
,
0xBE
,
0x22
,
0xCC
,
0x7A
,
0xEF
,
0x4B
,
0xEA
,
0x2A
,
0xD7
,
0x61
,
0x54
,
0x66
,
0xC2
,
0x51
,
0x70
,
0x84
,
0xC2
,
0x93
,
0x92
,
0x74
,
0xE7
,
0x91
,
0xFC
,
0xF1
,
0x1C
,
0x7F
,
0x3F
,
0x47
,
0xF7
,
0x4D
,
0x74
,
0xDF
,
0xD7
,
0xD3
,
0x93
,
0x06
,
0x80
,
0xBA
,
0x9B
,
0xCE
,
0xC4
,
0x52
,
0x64
,
0xF6
,
0x83
,
0x96
,
0x00
,
0x3D
,
0xE4
,
0x6F
,
0xF5
,
0xDD
,
0xA8
,
0xC5
,
0xFC
,
0x24
,
0xBC
,
0x4C
,
0x86
,
0x1C
,
0x97
,
0xEA
,
0x6B
,
0xA7
,
0x66
,
0x86
,
0x83
,
0xC6
,
0x31
,
0xAA
,
0x6A
,
0x89
,
0x9C
,
0x51
,
0x4C
,
0x0A
,
0xFB
,
0x15
,
0x2A
,
0x67
,
0x23
,
0x0A
,
0xA7
,
0x1E
,
0x7E
,
0xEA
,
0x62
,
0x13
,
0x6E
,
0x32
,
0xA6
,
0x3A
,
0xE7
,
0x39
,
0x37
,
0x3F
,
0xBB
,
0x1F
,
0x59
,
0x0C
,
0x54
,
0x70
,
0xCE
,
0xE8
,
0x16
,
0xC9
,
0xE4
,
0x2D
,
0xC3
,
0xB8
,
0xEB
,
0xB1
,
0x4E
,
0x3B
,
0x00
,
0xFA
,
0xD0
,
0xFD
,
0xB1
,
0x44
,
0x86
,
0x84
,
0x5F
,
0xBA
,
0x1D
,
0xA4
,
0x10
,
0xC8
,
0x7D
,
0xAC
,
0x90
,
0xC4
,
0xD2
,
0xF4
,
0x52
,
0xDD
,
0x68
,
0xC4
,
0x9D
,
0xEE
,
0x10
,
0x6E
,
0xE3
,
0xD5
,
0x1B
,
0xBD
,
0xF7
,
0xFD
,
0xBE
,
0x7A
,
0xF6
,
0xEA
,
0x2F
,
0x22
,
0xEA
,
0x8F
,
0x41
,
0xCB
,
0x88
,
0x94
,
0x0A
,
0x63
,
0x3C
,
0xF2
,
0x4B
,
0xDF
,
0x97
,
0x74
,
0xA6
,
0x41
,
0x55
,
0xAE
,
0xC9
,
0x4B
,
0xC7
,
0xA6
,
0x9D
,
0xA1
,
0xCD
,
0xC8
,
0x8F
,
0x74
,
0x08
,
0x15
,
0x00
,
0x7B
,
0x1D
,
0x2B
,
0xDB
,
0xAD
,
0xC9
,
0x9E
,
0x9E
,
0xAD
,
0x5D
,
0x6A
,
0x5F
,
0xEB
};
static
const
uint8_t
BIG_NUM_TEST_CASE_1_RESULT
[]
=
{
0x84
,
0x24
,
0x3B
,
0x5B
,
0x99
,
0x29
,
0x54
,
0xCD
,
0xD8
,
0x7E
,
0x38
,
0xE3
,
0x80
,
0xAA
,
0x7D
,
0xC7
,
0x30
,
0xD4
,
0xCA
,
0xE7
,
0x8B
,
0x3F
,
0xAE
,
0x0D
,
0xAE
,
0xCD
,
0x71
,
0x27
,
0x4D
,
0xE7
,
0x52
,
0x96
,
0x77
,
0x08
,
0x88
,
0x09
,
0xC9
,
0x4A
,
0xD3
,
0x09
,
0x55
,
0xC1
,
0xB5
,
0x78
,
0x98
,
0x2E
,
0x42
,
0x2D
,
0x28
,
0xEB
,
0xCE
,
0x2E
,
0x56
,
0xA5
,
0x15
,
0x1A
,
0xB4
,
0x13
,
0xFA
,
0x3A
,
0xB9
,
0xB3
,
0xE8
,
0x5C
,
0x79
,
0xDE
,
0x06
,
0xAE
,
0xBA
,
0x58
,
0x5F
,
0x71
,
0x56
,
0xCA
,
0x51
,
0xCF
,
0x00
,
0x42
,
0x6D
,
0xD9
,
0x8E
,
0x07
,
0x5D
,
0xA0
,
0x71
,
0xE4
,
0x86
,
0x56
,
0x7B
,
0x05
,
0x27
,
0x70
,
0x7E
,
0xEC
,
0x81
,
0x58
,
0xD3
,
0xBE
,
0x3A
,
0x27
,
0x3F
,
0x22
,
0x15
,
0xAB
,
0x7B
,
0x4E
,
0xC5
,
0x09
,
0xEF
,
0x02
,
0x6F
,
0xE7
,
0x00
,
0x40
,
0x71
,
0x70
,
0xC1
,
0x44
,
0xC7
,
0xED
,
0xFE
,
0xC6
,
0x86
,
0x10
,
0x12
,
0xF2
,
0x1B
,
0x51
,
0x40
,
0x02
,
0x2F
,
0xA1
,
0x90
,
0xE7
,
0x07
,
0xC7
,
0xFE
,
0x52
,
0x57
,
0xD6
,
0xB3
,
0x6E
,
0xB6
,
0xF3
,
0x3F
,
0xC9
,
0x25
,
0xCC
,
0x86
,
0xBC
,
0xEC
,
0x18
,
0x34
,
0x4A
,
0x4F
,
0xF6
,
0xE5
,
0x01
,
0x42
,
0xD7
,
0x7E
,
0xE4
,
0x54
,
0xAF
,
0xE4
,
0xA3
,
0x26
,
0x6C
,
0x01
,
0x0C
,
0x64
,
0xAD
,
0x1C
,
0xE0
,
0x41
,
0xAE
,
0x4B
,
0x40
,
0xB0
,
0xE7
,
0x67
,
0x08
,
0x16
,
0xE5
,
0x54
,
0x05
,
0x55
,
0x9E
,
0x20
,
0x3F
,
0x54
,
0x91
,
0xCF
,
0x2F
,
0x1F
,
0xE7
,
0xE3
,
0xF2
,
0x4A
,
0xF1
,
0x58
,
0x3F
,
0xFE
,
0x55
,
0x56
,
0x9A
,
0x3C
,
0xFB
,
0x63
,
0x32
,
0xF6
,
0x64
,
0x55
,
0x5C
,
0x6C
,
0xAA
,
0x79
,
0xE0
,
0x4F
,
0x47
,
0x36
,
0x32
,
0xDB
,
0x2A
,
0x3F
,
0xA1
,
0x70
,
0xAD
,
0x72
,
0x93
,
0xFB
,
0xD2
,
0xF9
,
0xE5
,
0x0F
,
0xDC
,
0x85
,
0x2C
,
0xB9
,
0x32
,
0x4E
,
0x9B
,
0x31
,
0x8C
,
0x8C
,
0xFB
,
0x21
,
0xCF
,
0xC3
,
0x76
,
0x22
,
0x04
,
0xF9
,
0xCD
,
0x7F
,
0xE0
};
static
const
uint8_t
BIG_NUM_TEST_CASE_2_RESULT
[]
=
{
0x1A
,
0xA5
,
0x23
,
0xA4
,
0x6B
,
0x19
,
0x79
,
0xF0
,
0xD0
,
0x62
,
0x8E
,
0xE7
,
0xC4
,
0x5C
,
0x41
,
0x54
,
0x54
,
0xF8
,
0xB6
,
0xC2
,
0xA7
,
0xF6
,
0x80
,
0x69
,
0xB3
,
0xE2
,
0x3E
,
0x0E
,
0xBD
,
0x73
,
0xB3
,
0xBC
,
0x3D
,
0xB6
,
0x18
,
0xE1
,
0xDC
,
0x07
,
0x2C
,
0xDA
,
0x37
,
0xA8
,
0x55
,
0xA0
,
0xE6
,
0x19
,
0x2C
,
0x12
,
0xD0
,
0x80
,
0x36
,
0x73
,
0x14
,
0xBA
,
0x59
,
0x97
,
0xDC
,
0x88
,
0x83
,
0x75
,
0x65
,
0x62
,
0x4D
,
0xA7
,
0x74
,
0x6A
,
0x0F
,
0xCB
,
0x3E
,
0x0F
,
0x63
,
0xF3
,
0x4D
,
0xFD
,
0xD0
,
0x99
,
0xE4
,
0xA7
,
0xF4
,
0xBB
,
0x10
,
0xE9
,
0xF1
,
0x57
,
0x4B
,
0xB5
,
0xC4
,
0x0A
,
0x79
,
0x5B
,
0xFB
,
0x9C
,
0xF2
,
0x01
,
0x52
,
0x9A
,
0x00
,
0xBE
,
0x59
,
0xD2
,
0xE8
,
0xE4
,
0xB4
,
0x46
,
0xD5
,
0xF4
,
0xE0
,
0xC1
,
0x99
,
0xDC
,
0xE8
,
0x88
,
0x62
,
0x34
,
0x52
,
0xE8
,
0x61
,
0xAC
,
0xA1
,
0x47
,
0x05
,
0xE7
,
0x01
,
0x2B
,
0x92
,
0x0B
,
0xD2
,
0x43
,
0x9D
,
0x57
,
0xC3
,
0x18
,
0x18
,
0x2D
,
0x6F
,
0xA6
,
0xB8
,
0x01
,
0xC5
,
0x2C
,
0xD3
,
0x9D
,
0x5E
,
0x1B
,
0x54
,
0x9C
,
0x61
,
0x32
,
0x5C
,
0x7D
,
0xA4
,
0xE4
,
0x65
,
0xA6
,
0x7E
,
0xB9
,
0xD2
,
0x39
,
0x65
,
0xB6
,
0x8D
,
0xB1
,
0xC1
,
0xFE
,
0xB3
,
0x67
,
0x9B
,
0x31
,
0xD3
,
0x45
,
0xCD
,
0xA5
,
0x94
,
0x3F
,
0x7C
,
0x4D
,
0x75
,
0x57
,
0x36
,
0x9A
,
0x78
,
0x23
,
0x32
,
0xE6
,
0xD4
,
0xFA
,
0xA3
,
0x15
,
0x47
,
0x53
,
0x58
,
0x08
,
0xAE
,
0xF0
,
0xC2
,
0x0A
,
0x5E
,
0x47
,
0x9A
,
0x83
,
0x7D
,
0x7E
,
0x40
,
0xA3
,
0xDA
,
0xA7
,
0xE3
,
0x19
,
0x9A
,
0xFE
,
0x81
,
0x3F
,
0x87
,
0xF9
,
0x40
,
0xA5
,
0x96
,
0xF3
,
0x1E
,
0x3D
,
0xAF
,
0xEC
,
0x1F
,
0x63
,
0xAA
,
0x89
,
0xF5
,
0x03
,
0xD4
,
0xD4
,
0x3C
,
0x47
,
0xEA
,
0x01
,
0xA2
,
0xFB
,
0x58
,
0x4A
,
0x40
,
0x86
,
0x68
,
0xE7
,
0x30
,
0x87
,
0x43
,
0xD8
,
0xEE
,
0xFF
,
0x02
,
0x01
,
0x0B
,
0xE7
,
0xC7
,
0xEF
,
0x6F
,
0x69
};
static
const
uint8_t
BIG_NUM_TEST_CASE_3_RESULT
[]
=
{
0x6C
,
0x16
,
0x45
,
0x3E
,
0x1F
,
0xEB
,
0x63
,
0xDE
,
0x06
,
0x95
,
0x62
,
0xC7
,
0x45
,
0x89
,
0xDA
,
0xBB
,
0xE4
,
0x5B
,
0x61
,
0x2D
,
0x80
,
0x46
,
0xFE
,
0x5F
,
0x48
,
0x2C
,
0xFC
,
0x6A
,
0x8F
,
0xAC
,
0x62
,
0xB0
,
0x36
,
0x85
,
0xD1
,
0xB5
,
0x0F
,
0xE9
,
0xAD
,
0x6C
,
0x2B
,
0x57
,
0x84
,
0xB4
,
0x12
,
0x31
,
0xF9
,
0xA0
,
0xF8
,
0xB3
,
0x27
,
0xE9
,
0xFD
,
0x86
,
0xE4
,
0x29
,
0x96
,
0x31
,
0x98
,
0x80
,
0x86
,
0x31
,
0xFE
,
0x0F
,
0xC5
,
0xD0
,
0x68
,
0xC1
,
0xA9
,
0x88
,
0x79
,
0xD5
,
0x28
,
0xAA
,
0x8C
,
0x68
,
0x19
,
0x3D
,
0xC4
,
0x9D
,
0xDC
,
0x0E
,
0xC4
,
0x01
,
0xEB
,
0x8C
,
0x12
,
0xBA
,
0x09
,
0x56
,
0x91
,
0x30
,
0x02
,
0xC4
,
0x8B
,
0x88
,
0xD5
,
0x73
,
0xA8
,
0xB5
,
0x36
,
0x2D
,
0x95
,
0x63
,
0x10
,
0x26
,
0xE3
,
0x21
,
0x52
,
0x75
,
0x99
,
0xA1
,
0xA6
,
0x34
,
0xA0
,
0xA6
,
0x9A
,
0x65
,
0x06
,
0xA3
,
0x03
,
0x5C
,
0x20
,
0xB4
,
0xE5
,
0x34
,
0xEF
,
0x40
,
0x03
,
0xFE
,
0x15
,
0xB7
,
0xBA
,
0xF4
,
0x0F
,
0x30
,
0x00
,
0x15
,
0xB2
,
0x05
,
0x17
,
0x41
,
0xE9
,
0xD7
,
0x26
,
0xB8
,
0x9B
,
0x78
,
0xAC
,
0xE7
,
0xF8
,
0xC5
,
0xA5
,
0xCB
,
0x08
,
0x65
,
0x12
,
0x89
,
0x00
,
0x48
,
0xE9
,
0x70
,
0x02
,
0xFE
,
0xDB
,
0xE2
,
0x2E
,
0x6B
,
0x16
,
0x89
,
0xD4
,
0x71
,
0x52
,
0x9D
,
0x2B
,
0xE5
,
0x6D
,
0x01
,
0x33
,
0x53
,
0xFD
,
0x2A
,
0x36
,
0xD7
,
0x27
,
0x94
,
0xC1
,
0x42
,
0x2D
,
0x4D
,
0x32
,
0x46
,
0x07
,
0x04
,
0x64
,
0x16
,
0xA2
,
0x75
,
0x50
,
0x77
,
0x1A
,
0x5B
,
0x4A
,
0x43
,
0x1A
,
0x64
,
0x78
,
0x69
,
0x63
,
0xB6
,
0x8E
,
0xB3
,
0x02
,
0x44
,
0x7A
,
0xDC
,
0xAC
,
0x68
,
0xF5
,
0x8C
,
0xE4
,
0x8E
,
0x94
,
0xC9
,
0xAE
,
0x4A
,
0x5C
,
0x01
,
0x04
,
0xFF
,
0xBB
,
0x87
,
0xD7
,
0x4C
,
0x62
,
0xF6
,
0x8F
,
0x9F
,
0xD7
,
0x27
,
0x99
,
0xEF
,
0x96
,
0xAB
,
0xB9
,
0x9B
,
0xB3
,
0x6E
,
0x92
,
0xDB
,
0x55
,
0xFB
,
0x46
,
0x1C
,
0x3B
,
0x1F
,
0xC2
,
0xF9
,
0xCC
,
0x12
,
0x23
,
0x0F
,
0x0D
,
0xD7
,
0xCE
,
0x22
,
0xFD
,
0x99
,
0xF4
,
0x00
,
0xED
,
0xD0
,
0xC4
,
0xA6
,
0xE1
,
0xAA
,
0x8B
,
0x22
,
0x80
,
0x7F
,
0x56
,
0xF1
,
0x10
,
0x55
,
0xAF
,
0x9F
,
0x5A
,
0xC7
,
0xA2
,
0xCD
,
0x48
,
0xAA
,
0x6D
,
0x5E
,
0x37
,
0x8F
,
0xA1
,
0xC4
,
0xA0
,
0x3B
,
0x78
,
0xC8
,
0xB6
,
0xFD
,
0x0A
,
0x7E
,
0xE1
,
0x61
,
0x63
,
0xFC
,
0x33
,
0x6B
,
0x50
,
0xEB
,
0xE7
,
0x13
,
0x6A
,
0x84
,
0xF7
,
0x33
,
0xB4
,
0x38
,
0x49
,
0xF0
,
0x31
,
0x0A
,
0x05
,
0x7C
,
0x10
,
0xDF
,
0xF6
,
0x4B
,
0x4F
,
0x1F
,
0x79
,
0x96
,
0xF1
,
0x37
,
0x7D
,
0x80
,
0x3B
,
0xF1
,
0x73
,
0xB4
,
0x4E
,
0x62
,
0x7D
,
0x86
,
0x7B
,
0x43
,
0x51
,
0x06
,
0x0B
,
0xA0
,
0xDC
,
0xA7
,
0xD5
,
0x3D
,
0xF2
,
0xD7
,
0xD3
,
0x3C
,
0x57
,
0x9B
,
0x64
,
0xB1
,
0xDE
,
0x69
,
0x90
,
0x43
,
0xEE
,
0xD1
,
0xC6
,
0xAE
,
0xDD
,
0x67
,
0x02
,
0xDF
,
0xA1
,
0x84
,
0x7B
,
0x5D
,
0xB3
,
0xD8
};
static
const
uint8_t
BIG_NUM_TEST_CASE_4_RESULT
[]
=
{
0x31
,
0xEA
,
0x6E
,
0x6B
,
0x8C
,
0xE0
,
0x0F
,
0x62
,
0xA0
,
0xDD
,
0xE1
,
0x3E
,
0xAD
,
0xB1
,
0xA5
,
0xA2
,
0xC8
,
0xDE
,
0x3D
,
0x61
,
0x9D
,
0x37
,
0xE1
,
0x66
,
0xF7
,
0xF5
,
0xCC
,
0x11
,
0x17
,
0xFD
,
0x2A
,
0xA2
,
0x00
,
0x36
,
0xFC
,
0x72
,
0x74
,
0x19
,
0xC1
,
0xA2
,
0x0C
,
0x35
,
0x05
,
0x34
,
0xB0
,
0x64
,
0xBE
,
0x7E
,
0xD0
,
0x96
,
0xBF
,
0xCA
,
0x48
,
0x92
,
0xA9
,
0x0B
,
0x4A
,
0x8C
,
0x56
,
0x3F
,
0xE6
,
0xDA
,
0xFC
,
0xE6
,
0x66
,
0xD4
,
0xF8
,
0x23
,
0x3D
,
0x6F
,
0xC6
,
0xC3
,
0x21
,
0x27
,
0x10
,
0x2A
,
0x65
,
0xE3
,
0x15
,
0x57
,
0xC9
,
0xE4
,
0x35
,
0xE4
,
0xC1
,
0x4D
,
0x1C
,
0x4D
,
0x89
,
0xF6
,
0xF6
,
0x67
,
0x66
,
0x6F
,
0x79
,
0x77
,
0x64
,
0xCA
,
0x32
,
0x52
,
0x2A
,
0xBC
,
0xAE
,
0xD3
,
0xB4
,
0x58
,
0x9F
,
0x47
,
0xA5
,
0x68
,
0x94
,
0x34
,
0x97
,
0x19
,
0x9F
,
0x48
,
0x33
,
0x4C
,
0x2D
,
0x94
,
0xD3
,
0xC0
,
0xBD
,
0x66
,
0x07
,
0x4A
,
0xE0
,
0x4E
,
0x18
,
0x08
,
0xDE
,
0x82
,
0x1A
,
0x26
,
0xE7
,
0x3F
,
0x4E
,
0x2F
,
0x4D
,
0x8B
,
0x1B
,
0x8F
,
0x23
,
0x81
,
0x51
,
0xCA
,
0xDC
,
0x9B
,
0x6F
,
0xCB
,
0x49
,
0x9B
,
0x2E
,
0x0C
,
0x24
,
0x8B
,
0x08
,
0x9E
,
0xFF
,
0x1C
,
0xEA
,
0x40
,
0x59
,
0xB3
,
0xDD
,
0xC6
,
0x29
,
0x1F
,
0xBA
,
0xA4
,
0x2D
,
0x9B
,
0x5C
,
0x78
,
0x9F
,
0x84
,
0xC6
,
0x3B
,
0xFB
,
0xCB
,
0xA0
,
0x9E
,
0x07
,
0xB9
,
0x0D
,
0x6A
,
0x88
,
0x91
,
0x0C
,
0x67
,
0xFC
,
0x1E
,
0xAF
,
0xA2
,
0x54
,
0x95
,
0x7B
,
0x50
,
0xBD
,
0x7D
,
0x40
,
0x3D
,
0x3A
,
0x58
,
0x13
,
0x14
,
0x3C
,
0x5C
,
0xEE
,
0xF6
,
0x95
,
0x9C
,
0x0E
,
0x65
,
0xA7
,
0x4F
,
0x67
,
0x91
,
0xA0
,
0xE8
,
0xB7
,
0xC0
,
0xE8
,
0xD7
,
0x3E
,
0x06
,
0x35
,
0xB6
,
0x82
,
0x65
,
0x28
,
0xA7
,
0x29
,
0xDA
,
0xA6
,
0xC1
,
0xBD
,
0xBA
,
0x72
,
0x41
,
0xBE
,
0x77
,
0x4F
,
0x30
,
0xEB
,
0x8E
,
0xB1
,
0x29
,
0x71
,
0x44
,
0x6B
,
0x3A
,
0xD8
,
0xEA
,
0x87
,
0x1A
,
0x29
,
0x41
,
0xA4
,
0x2B
,
0x59
,
0x41
,
0x13
,
0x4A
,
0xC8
,
0x60
,
0xA1
,
0x61
,
0x13
,
0x30
,
0xA6
,
0x4B
,
0x4F
,
0x6A
,
0x7C
,
0x82
,
0xF3
,
0x78
,
0x20
,
0x20
,
0x52
,
0x5B
,
0xED
,
0xD5
,
0xF8
,
0xBF
,
0x03
,
0x15
,
0xD8
,
0xBB
,
0x71
,
0x62
,
0x88
,
0x73
,
0xEB
,
0xFC
,
0x32
,
0x4E
,
0x20
,
0x17
,
0xEA
,
0xD6
,
0xBA
,
0xDF
,
0x55
,
0x26
,
0x6C
,
0x19
,
0x7F
,
0x7F
,
0x62
,
0x83
,
0x43
,
0x6C
,
0xA9
,
0xBD
,
0x12
,
0x2F
,
0x6B
,
0x8E
,
0x55
,
0x18
,
0x84
,
0xD6
,
0x0E
,
0x11
,
0xA2
,
0x78
,
0x05
,
0xD2
,
0x4F
,
0xEA
,
0xB3
,
0x61
,
0x47
,
0x9C
,
0xB2
,
0xCF
,
0x5C
,
0xE1
,
0xFF
,
0xC8
,
0x54
,
0x56
,
0x93
,
0x2F
,
0x71
,
0xE0
,
0xF5
,
0x85
,
0xC8
,
0x98
,
0x0C
,
0x0E
,
0x02
,
0x4A
,
0x1C
,
0xDB
,
0xB6
,
0x3F
,
0x78
,
0x4C
,
0x4F
,
0x1E
,
0x54
,
0xF9
,
0x48
,
0x2C
,
0xB1
,
0x6E
,
0x4D
,
0xD6
,
0x25
,
0xB3
,
0x91
,
0x5C
,
0x2B
,
0x9F
,
0x3A
,
0xFD
,
0xEB
,
0x75
,
0x44
,
0x17
};
static
const
BigNumTestCase
BIG_NUM_TEST_CASES
[]
=
{
// case 1:
{
.
baseLength
=
ARRAY_SIZE
(
BASE_HEX_32
),
.
expLength
=
ARRAY_SIZE
(
EXP_HEX_1
),
.
prime
=
PRIME_HEX_256
,
.
base
=
BASE_HEX_32
,
.
exp
=
EXP_HEX_1
,
.
result
=
BIG_NUM_TEST_CASE_1_RESULT
},
// case 2:
{
.
baseLength
=
ARRAY_SIZE
(
BASE_HEX_256
),
.
expLength
=
ARRAY_SIZE
(
EXP_HEX_28
),
.
prime
=
PRIME_HEX_256
,
.
base
=
BASE_HEX_256
,
.
exp
=
EXP_HEX_28
,
.
result
=
BIG_NUM_TEST_CASE_2_RESULT
},
// case 3:
{
.
baseLength
=
ARRAY_SIZE
(
BASE_HEX_32
),
.
expLength
=
ARRAY_SIZE
(
EXP_HEX_1
),
.
prime
=
PRIME_HEX_384
,
.
base
=
BASE_HEX_32
,
.
exp
=
EXP_HEX_1
,
.
result
=
BIG_NUM_TEST_CASE_3_RESULT
},
// case 4:
{
.
baseLength
=
ARRAY_SIZE
(
BASE_HEX_384
),
.
expLength
=
ARRAY_SIZE
(
EXP_HEX_32
),
.
prime
=
PRIME_HEX_384
,
.
base
=
BASE_HEX_384
,
.
exp
=
EXP_HEX_32
,
.
result
=
BIG_NUM_TEST_CASE_4_RESULT
}
};
enum
{
SHA256_MSG_MAX_SIZE
=
1024
,
SHA256_TEST_TIMES
=
100
,
SHA256_TEST_MIN_LIMIT
=
64
,
// test msg length form 1 to 64
GEN_RANDOM_MAX_SIZE
=
1024
,
GEN_RANDOM_TEST_TIMES
=
100
,
GEN_RANDOM_MIN_LIMIT
=
64
,
// test generate random from 1 to 64
GEN_RANDOM_TEST_REPEAT_SIZE
=
32
,
GEN_RANDOM_TEST_REPEAT_TIMES
=
100
,
TEST_HMAC_KEY_LEN
=
32
,
// equal to PSK_LEN PAKE_HMAC_KEY_LEN SHA256_LEN HC_SHA256_LEN
TEST_HMAC_ISALIAS_TRUE_MSG_LENGTH
=
32
,
// msg length when isAlias is true ISO_KEY_ALIAS_LEN
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
=
32
,
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
=
32
,
#define GENERATE_RETURN_KEY_STR "hichain_return_key"
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
=
16
,
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
=
16
,
#define HICHAIN_RETURN_KEY "hichain_return_key"
HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_BASEKEY_LEN
=
64
,
HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_SALT_LEN
=
32
,
#define TMP_AUTH_KEY_FACTOR "hichain_tmp_auth_enc_key"
HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_OUTKEY_LEN
=
32
,
HKDF_ISO_PSK_DERIVE_SESSIONKEY_BASEKEY_LEN
=
32
,
HKDF_ISO_PSK_DERIVE_SESSIONKEY_SALT_LEN
=
32
,
#define GENERATE_SESSION_KEY_STR "hichain_iso_session_key"
HKDF_ISO_PSK_DERIVE_SESSIONKEY_OUTKEY_LEN
=
32
,
HKDF_NEW_PAKE_PSK_DERIVE_SECRET_BASEKEY_LEN
=
32
*
2
,
// PAKE_PSK_LEN * BYTE_TO_HEX_OPER_LENGTH
HKDF_NEW_PAKE_PSK_DERIVE_SECRET_SALT_LEN
=
16
,
#define HICHAIN_SPEKE_BASE_INFO "hichain_speke_base_info"
HKDF_NEW_PAKE_PSK_DERIVE_SECRET_OUTKEY_LEN
=
32
,
HKDF_NEW_PAKE_SHAREDSECRET_DERIVE_SESSIONKEY_BASEKEY_LEN
=
SHA256_LEN
,
HKDF_NEW_PAKE_SHAREDSECRET_DERIVE_SESSIONKEY_SALT_LEN
=
16
,
#define HICHAIN_SPEKE_SESSIONKEY_INFO "hichain_speke_sessionkey_info"
HKDF_NEW_PAKE_SHAREDSECRET_DERIVE_SESSIONKEY_OUTKEY_LEN
=
32
,
HKDF_PAKE_PSK_DERIVE_SECRET_BASEKEY_LEN
=
32
*
2
,
// PAKE_PSK_LEN * BYTE_TO_HEX_OPER_LENGTH
HKDF_PAKE_PSK_DERIVE_SECRET_SALT_LEN
=
16
,
HKDF_PAKE_PSK_DERIVE_SECRET_OUTKEY_LEN
=
32
,
HKDF_PAKE_SHAREDSECRET_DERIVE_UNIONKEY_SALT_LEN
=
16
,
HKDF_PAKE_SHAREDSECRET_DERIVE_UNIONKEY_OUTKEY_LEN
=
48
,
IMPORT_SYMMETRIC_KEY_KEYALIAS_LEN_MAX
=
32
,
IMPORT_SYMMETRIC_KEY_KEYALIAS_LEN_MIN
=
1
,
IMPORT_SYMMETRIC_KEY_AUTHTOKEN_LEN
=
32
,
};
enum
{
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_4
=
4
,
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_32
=
32
,
// the meaning of 16 * 2 + 256 * 2 is
// length of randSelf + length of randPeer + length of authIdPeer + length of authIdSelf
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_RAND_AUTH_ID_SELF_PEER
=
16
*
2
+
256
*
2
,
// MAC FF:FF:FF:FF:FF:FF
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_MAC
=
16
*
2
+
6
*
2
,
// UDID FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_UDID
=
16
*
2
+
16
*
2
,
// IMEI 999999999999999
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_IMEI
=
16
*
2
+
15
*
2
,
};
static
const
uint32_t
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_ARRAY
[]
=
{
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_4
,
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_32
,
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_RAND_AUTH_ID_SELF_PEER
,
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_MAC
,
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_UDID
,
TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_IMEI
,
};
static
const
char
SHA256_EXAMPLE_MESSAGE
[]
=
"hichain-sha256-example"
;
static
const
uint8_t
SHA256_EXAMPLE_RESULT
[
SHA256_LEN
]
=
{
0x53
,
0x0a
,
0x91
,
0x67
,
0xab
,
0x1f
,
0xf0
,
0x18
,
0xfa
,
0x1b
,
0x8e
,
0xb1
,
0x03
,
0xcf
,
0x1c
,
0x8a
,
0x1b
,
0x7b
,
0x05
,
0x0d
,
0xfb
,
0x2d
,
0xe0
,
0x60
,
0x19
,
0x64
,
0x50
,
0x76
,
0x69
,
0xd6
,
0xc5
,
0x79
,
};
static
const
char
HMAC_EXAMPLE_MESSAGE
[]
=
"hichain hmac message example"
;
static
const
uint8_t
HMAC_EXAMPLE_KEY
[
TEST_HMAC_KEY_LEN
]
=
{
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
0xab
,
0xcd
,
0xef
,
};
static
const
uint8_t
HMAC_EXAMPLE_RESULT
[
HMAC_LEN
]
=
{
0x99
,
0xbe
,
0xaf
,
0x20
,
0x84
,
0xeb
,
0xae
,
0x5d
,
0xc4
,
0x1d
,
0x62
,
0x19
,
0xcb
,
0x52
,
0xe1
,
0x43
,
0xa1
,
0xf3
,
0x74
,
0xf8
,
0x33
,
0x61
,
0xe0
,
0x82
,
0x61
,
0xfe
,
0x19
,
0x09
,
0x1f
,
0xac
,
0x9d
,
0xb9
,
};
// Hashing type: SHA-256
static
const
char
HKDF_EXAMPLE_MESSAGE
[]
=
"hello hichain"
;
static
const
uint8_t
HKDF_EXAMPLE_SALT
[]
=
{
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
};
static
const
char
HKDF_EXAMPLE_INFO
[]
=
"hichain hkdf info"
;
static
const
uint8_t
HKDF_EXAMPLE_RESULT_KEY
[]
=
{
0x4e
,
0xc8
,
0xf7
,
0x6a
,
0x03
,
0xe9
,
0x18
,
0xbf
,
0xaa
,
0xaa
,
0x22
,
0xc1
,
0xd7
,
0x7e
,
0x0a
,
0xa8
,
};
static
const
char
hkdfCaseNameIsoSessionKeyDeriveReturnKey
[]
=
"iso sessionkey derive returnkey"
;
static
const
char
hkdfCaseNamePakeSessionKeyDeriveReturnKey
[]
=
"pake sessionkey derive returnkey"
;
static
const
char
hkdfCaseNameIsoPskDeriveSessionKey
[]
=
"iso psk derive sessionkey"
;
static
const
char
hkdfCaseNameNewPakePskDeriveSecret
[]
=
"new pake psk derive secret"
;
static
const
char
hkdfCaseNameNewPakeSharedSecretDeriveSessionKey
[]
=
"new pake sharedSecret derive sessionkey"
;
static
const
char
hkdfCaseNamePakePskDeriveSecretIsAliasFalse
[]
=
"pake psk derive secret isAlias false"
;
static
const
char
hkdfCaseNamePakeSharedSecretDeriveUnionKey
[]
=
"pake sharedSecret derive unionkey"
;
enum
{
HKDF_OUT_KEY_LENGTH_RANGE_16
=
16
,
HKDF_OUT_KEY_LENGTH_RANGE_32
=
32
,
HKDF_OUT_KEY_LENGTH_RANGE_64
=
64
,
HKDF_OUT_KEY_LENGTH_RANGE_128
=
128
,
HKDF_OUT_KEY_LENGTH_RANGE_256
=
256
,
HKDF_OUT_KEY_LENGTH_RANGE_512
=
512
,
HKDF_OUT_KEY_LENGTH_RANGE_1024
=
1024
,
HKDF_CASE_PAKE_SHARED_SECRET_DERIVE_UNION_KEY_BASE_KEY_LENGTH_ED25519
=
32
,
HKDF_CASE_PAKE_SHARED_SECRET_DERIVE_UNION_KEY_BASE_KEY_LENGTH_P256
=
64
,
};
static
const
struct
HkdfTestCase
{
const
char
*
caseName
;
uint32_t
baseKeyLength
;
uint32_t
saltLength
;
const
char
*
keyInfo
;
uint32_t
outKeyLength
;
}
g_hkdfTestCase
[]
=
{
{
.
caseName
=
hkdfCaseNameIsoSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
GENERATE_RETURN_KEY_STR
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_16
,
},
{
.
caseName
=
hkdfCaseNameIsoSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
GENERATE_RETURN_KEY_STR
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_32
,
},
{
.
caseName
=
hkdfCaseNameIsoSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
GENERATE_RETURN_KEY_STR
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_64
,
},
{
.
caseName
=
hkdfCaseNameIsoSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
GENERATE_RETURN_KEY_STR
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_128
,
},
{
.
caseName
=
hkdfCaseNameIsoSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
GENERATE_RETURN_KEY_STR
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_256
,
},
{
.
caseName
=
hkdfCaseNameIsoSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
GENERATE_RETURN_KEY_STR
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_512
,
},
{
.
caseName
=
hkdfCaseNameIsoSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_ISO_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
GENERATE_RETURN_KEY_STR
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_1024
,
},
{
.
caseName
=
hkdfCaseNamePakeSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_RETURN_KEY
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_16
,
},
{
.
caseName
=
hkdfCaseNamePakeSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_RETURN_KEY
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_32
,
},
{
.
caseName
=
hkdfCaseNamePakeSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_RETURN_KEY
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_64
,
},
{
.
caseName
=
hkdfCaseNamePakeSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_RETURN_KEY
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_128
,
},
{
.
caseName
=
hkdfCaseNamePakeSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_RETURN_KEY
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_256
,
},
{
.
caseName
=
hkdfCaseNamePakeSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_RETURN_KEY
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_512
,
},
{
.
caseName
=
hkdfCaseNamePakeSessionKeyDeriveReturnKey
,
.
baseKeyLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_PAKE_SESSIONKEY_DERIVE_RETURNKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_RETURN_KEY
,
.
outKeyLength
=
HKDF_OUT_KEY_LENGTH_RANGE_1024
,
},
{
.
caseName
=
hkdfCaseNameIsoPskDeriveSessionKey
,
.
baseKeyLength
=
HKDF_ISO_PSK_DERIVE_SESSIONKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_ISO_PSK_DERIVE_SESSIONKEY_SALT_LEN
,
.
keyInfo
=
GENERATE_SESSION_KEY_STR
,
.
outKeyLength
=
HKDF_ISO_PSK_DERIVE_SESSIONKEY_OUTKEY_LEN
,
},
{
.
caseName
=
hkdfCaseNameNewPakePskDeriveSecret
,
.
baseKeyLength
=
HKDF_NEW_PAKE_PSK_DERIVE_SECRET_BASEKEY_LEN
,
.
saltLength
=
HKDF_NEW_PAKE_PSK_DERIVE_SECRET_SALT_LEN
,
.
keyInfo
=
HICHAIN_SPEKE_BASE_INFO
,
.
outKeyLength
=
HKDF_NEW_PAKE_PSK_DERIVE_SECRET_OUTKEY_LEN
,
},
{
.
caseName
=
hkdfCaseNameNewPakeSharedSecretDeriveSessionKey
,
.
baseKeyLength
=
HKDF_NEW_PAKE_SHAREDSECRET_DERIVE_SESSIONKEY_BASEKEY_LEN
,
.
saltLength
=
HKDF_NEW_PAKE_SHAREDSECRET_DERIVE_SESSIONKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_SPEKE_SESSIONKEY_INFO
,
.
outKeyLength
=
HKDF_NEW_PAKE_SHAREDSECRET_DERIVE_SESSIONKEY_OUTKEY_LEN
,
},
{
.
caseName
=
hkdfCaseNamePakePskDeriveSecretIsAliasFalse
,
.
baseKeyLength
=
HKDF_PAKE_PSK_DERIVE_SECRET_BASEKEY_LEN
,
.
saltLength
=
HKDF_PAKE_PSK_DERIVE_SECRET_SALT_LEN
,
.
keyInfo
=
HICHAIN_SPEKE_BASE_INFO
,
.
outKeyLength
=
HKDF_PAKE_PSK_DERIVE_SECRET_OUTKEY_LEN
,
},
{
.
caseName
=
hkdfCaseNamePakeSharedSecretDeriveUnionKey
,
.
baseKeyLength
=
HKDF_CASE_PAKE_SHARED_SECRET_DERIVE_UNION_KEY_BASE_KEY_LENGTH_ED25519
,
.
saltLength
=
HKDF_PAKE_SHAREDSECRET_DERIVE_UNIONKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_SPEKE_SESSIONKEY_INFO
,
.
outKeyLength
=
HKDF_PAKE_SHAREDSECRET_DERIVE_UNIONKEY_OUTKEY_LEN
,
},
{
.
caseName
=
hkdfCaseNamePakeSharedSecretDeriveUnionKey
,
.
baseKeyLength
=
HKDF_CASE_PAKE_SHARED_SECRET_DERIVE_UNION_KEY_BASE_KEY_LENGTH_P256
,
.
saltLength
=
HKDF_PAKE_SHAREDSECRET_DERIVE_UNIONKEY_SALT_LEN
,
.
keyInfo
=
HICHAIN_SPEKE_SESSIONKEY_INFO
,
.
outKeyLength
=
HKDF_PAKE_SHAREDSECRET_DERIVE_UNIONKEY_OUTKEY_LEN
,
},
};
enum
{
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH
=
32
,
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_SHARED_KEY_LENGTH
=
32
,
TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_AUTH_ID_LENGTH
=
32
,
};
enum
{
TEST_IMPORT_SYMMETRIC_KEY_AUTH_ID_LENGTH_32
=
32
,
TEST_IMPORT_SYMMETRIC_KEY_AUTH_ID_LENGTH_64
=
64
,
};
enum
{
TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH
=
32
,
};
// TestExportImportSignVerify
enum
{
TEST_EX_IM_SN_VF_EXTRA_INFO_AUTH_ID_LENGTH
=
32
,
TEST_EX_IM_SN_VF_KEY_ALIAS_LENGTH
=
64
,
TEST_EX_IM_SN_VF_KEY_LENGTH
=
32
,
TEST_EX_IM_SN_VF_OUT_PUB_KEY_LENGTH
=
32
,
TEST_SIGN_MESSAGE_LENGTH_1
=
1
,
TEST_SIGN_MESSAGE_LENGTH_2
=
2
,
TEST_SIGN_MESSAGE_LENGTH_4
=
4
,
TEST_SIGN_MESSAGE_LENGTH_8
=
8
,
TEST_SIGN_MESSAGE_LENGTH_16
=
16
,
TEST_SIGN_MESSAGE_LENGTH_32
=
32
,
TEST_SIGN_MESSAGE_LENGTH_64
=
64
,
TEST_SIGN_MESSAGE_LENGTH_128
=
128
,
TEST_SIGN_MESSAGE_LENGTH_256
=
256
,
TEST_SIGN_MESSAGE_LENGTH_512
=
512
,
TEST_SIGN_MESSAGE_LENGTH_1024
=
1024
,
TEST_SIGN_SIGNATURE_LENGTH
=
64
,
};
static
const
uint32_t
TEST_SIGN_MSG_LENGTHES
[]
=
{
TEST_SIGN_MESSAGE_LENGTH_1
,
TEST_SIGN_MESSAGE_LENGTH_2
,
TEST_SIGN_MESSAGE_LENGTH_4
,
TEST_SIGN_MESSAGE_LENGTH_8
,
TEST_SIGN_MESSAGE_LENGTH_16
,
TEST_SIGN_MESSAGE_LENGTH_32
,
TEST_SIGN_MESSAGE_LENGTH_64
,
TEST_SIGN_MESSAGE_LENGTH_128
,
TEST_SIGN_MESSAGE_LENGTH_256
,
TEST_SIGN_MESSAGE_LENGTH_512
,
TEST_SIGN_MESSAGE_LENGTH_1024
,
};
static
const
char
TEST_EXPORT_DIFFERENT_ERROR_MESSAGE
[]
=
"two different public keys are exported"
;
// g_largePrimeNumberHex384 and g_largePrimeNumberHex256 are from
// base/security/device_auth/services/protocol/src/pake_protocol/pake_protocol_dl_common/pake_protocol_dl_common.c
static
const
char
LARGE_PRIME_NUM_HEX_384
[]
=
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74"
"020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437"
"4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
"EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF05"
"98DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB"
"9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
"E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
"3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33"
"A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
"ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864"
"D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E2"
"08E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF"
;
static
const
char
LARGE_PRIME_NUM_HEX_256
[]
=
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74"
"020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437"
"4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
"EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF05"
"98DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB"
"9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
"E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
"3995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF"
;
enum
{
PAKE_DL_PRIME_LEN_256
=
256
,
PAKE_DL_PRIME_LEN_384
=
384
,
};
enum
{
TEST_CHECK_DL_VALUE_ONE
=
1
,
TEST_CHECK_DL_VALUE_TWO
=
2
,
};
enum
{
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
=
32
,
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
=
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
/
2
,
// 16
};
static
const
uint8_t
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL
[
TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL
]
=
{
/* */
/* */
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
};
static
const
uint8_t
TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF
[
TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF
]
=
{
/* */
/* */
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
0xab
,
0xcd
,
0xef
,
0x01
,
0x23
,
0x45
,
0x67
,
0x89
,
};
#ifdef __cplusplus
}
#endif
#endif // HC_ALG_TEST_CASE_H
\ No newline at end of file
security_lite/deviceauth_basic_deps/hc_condition_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_condition_test.h"
#include <hctest.h>
#include <parameter.h>
#include <pthread.h>
#include <securec.h>
#include <semaphore.h>
#include <stdlib.h>
#include <unistd.h>
#include "print_log.h"
#include "test_timer.h"
#ifdef __cplusplus
extern
"C"
{
#endif
typedef
struct
{
pthread_cond_t
*
cond
;
pthread_mutex_t
*
mutex
;
sem_t
*
sem
;
int32_t
semState
;
int32_t
condState
;
}
ThreadTestArgs
;
#define REQUIRED_SEM_DEFAULT_COUNT 20
#define REQUIRED_SEM_COUNT 20
#define REQUIRED_ATTR_DEFAULT_COUNT 20
#define REQUIRED_ATTR_COUNT 20
/* sem_wait thread test */
static
void
*
ThreadSemWait
(
void
*
args
)
{
LOGI
(
"into ThreadSemWait"
);
int
res
;
ThreadTestArgs
*
semArgs
=
(
ThreadTestArgs
*
)
args
;
TEST_ASSERT_NOT_NULL
(
semArgs
->
sem
);
TEST_ASSERT_NOT_EQUAL
(
0
,
semArgs
->
semState
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_wait
((
sem_t
*
)
semArgs
->
sem
));
// after sem_post
LOGI
(
"sem_wait result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
semArgs
->
semState
=
0
;
return
args
;
}
/* sem_post thread test */
static
void
*
ThreadSemPost
(
void
*
args
)
{
LOGI
(
"into ThreadSemPost"
);
int
res
;
ThreadTestArgs
*
semArgs
=
(
ThreadTestArgs
*
)
args
;
TEST_ASSERT_NOT_NULL
(
semArgs
->
sem
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_post
((
sem_t
*
)
semArgs
->
sem
));
LOGI
(
"sem_post result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
return
args
;
}
/* pthread_cond_wait thread test */
static
void
*
ThreadCondWait
(
void
*
args
)
{
LOGI
(
"into ThreadCondWait"
);
int
res
;
ThreadTestArgs
*
condArgs
=
(
ThreadTestArgs
*
)
args
;
TEST_ASSERT_NOT_NULL
(
condArgs
->
cond
);
TEST_ASSERT_NOT_NULL
(
condArgs
->
mutex
);
TEST_ASSERT_NOT_EQUAL
(
0
,
condArgs
->
condState
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_cond_wait
(
condArgs
->
cond
,
condArgs
->
mutex
));
// after pthread_cond_signal
LOGI
(
"pthread_cond_wait result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
condArgs
->
condState
=
0
;
return
args
;
}
/* pthread_cond_signal thread test */
static
void
*
ThreadCondSignal
(
void
*
args
)
{
LOGI
(
"into ThreadCondSignal"
);
int
res
;
ThreadTestArgs
*
testArgs
=
(
ThreadTestArgs
*
)
args
;
TEST_ASSERT_NOT_NULL
(
testArgs
->
cond
);
TEST_ASSERT_NOT_NULL
(
testArgs
->
mutex
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_cond_signal
(
testArgs
->
cond
));
LOGI
(
"pthread_cond_signal result = %d"
,
res
);
return
args
;
}
/* sem_init and sem_destroy test */
static
void
TestSemInit
(
int
count
)
{
int
res
;
sem_t
sem
[
count
];
res
=
memset_s
(
sem
,
sizeof
(
sem
),
0
,
sizeof
(
sem
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_init
(
&
sem
[
i
],
0
,
0
));
LOGI
(
"sem_init result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_destroy
(
&
sem
[
i
]));
LOGI
(
"sem_destroy result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
}
/* sem_wait test */
static
void
TestSemWait
(
int
count
)
{
int
res
;
pthread_attr_t
attr
;
pthread_t
threads
[
count
];
res
=
memset_s
(
threads
,
sizeof
(
threads
),
0
,
sizeof
(
threads
));
TEST_ASSERT_EQUAL
(
0
,
res
);
sem_t
sem
=
{
0
};
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_init
(
&
attr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_init
(
&
sem
,
0
,
0
));
LOGI
(
"sem_init result = %d"
,
res
);
ThreadTestArgs
args
=
{
.
sem
=
&
sem
,
.
semState
=
-
1
,
};
TEST_ASSERT_EQUAL
(
0
,
res
);
/* create phread to wait */
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_create
(
&
threads
[
i
],
&
attr
,
ThreadSemWait
,
&
args
));
LOGI
(
"create sem_wait thread result = %d"
,
res
);
int
sleepSeconds
=
rand
()
%
(
WAIT_IN_SEM_SECONDS_MAX
-
WAIT_IN_SEM_SECONDS_MIN
)
+
WAIT_IN_SEM_SECONDS_MIN
;
sleep
(
sleepSeconds
);
/* sleep seconds then create thread to post */
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_create
(
&
threads
[
i
],
&
attr
,
ThreadSemPost
,
&
args
));
LOGI
(
"create sem_post thread result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
sleep
(
sleepSeconds
);
TEST_ASSERT_EQUAL
(
0
,
args
.
semState
);
}
}
/* sem_post test */
static
void
TestSemPost
(
int
count
)
{
int
res
;
sem_t
sem
[
count
];
res
=
memset_s
(
sem
,
sizeof
(
sem
),
0
,
sizeof
(
sem
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_init
(
&
sem
[
i
],
0
,
0
));
LOGI
(
"sem_init int TestSemPost result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_post
(
&
sem
[
i
]));
LOGI
(
"sem_post result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_post
(
&
sem
[
i
]));
LOGI
(
"sem_post result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
sem_destroy
(
&
sem
[
i
]));
LOGI
(
"sem_destroy in TestSemPost result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
}
/* pthread_condattr_init and pthread_condattr_destroy test */
static
void
TestAttrConInit
(
int
count
)
{
int
res
;
pthread_condattr_t
attr
[
count
];
res
=
memset_s
(
attr
,
sizeof
(
attr
),
0
,
sizeof
(
attr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_condattr_init
(
&
attr
[
i
]));
LOGI
(
"pthread_condattr_init result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_condattr_destroy
(
&
attr
[
i
]));
LOGI
(
"pthread_condattr_destroy result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
}
/* pthread_cond_init and pthread_cond_destroy test */
static
void
TestConInit
(
int
count
)
{
int
res
;
pthread_condattr_t
attr
=
{
0
};
pthread_cond_t
cond
[
count
];
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_condattr_init
(
&
attr
));
LOGI
(
"pthread_condattr_init in TestConInit result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
res
=
memset_s
(
cond
,
sizeof
(
cond
),
0
,
sizeof
(
cond
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_cond_init
(
&
cond
[
i
],
&
attr
));
LOGI
(
"pthread_cond_init result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_cond_destroy
(
&
cond
[
i
]));
LOGI
(
"pthread_cond_destroy result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
}
/* pthread_cond_wait and pthread_cond_signal test */
static
void
TestConWait
(
int
count
)
{
int
res
;
pthread_attr_t
pthreadAttr
;
pthread_condattr_t
attr
=
{
0
};
pthread_cond_t
cond
;
pthread_mutex_t
mutex
;
pthread_t
threads
[
count
];
res
=
memset_s
(
&
mutex
,
sizeof
(
mutex
),
0
,
sizeof
(
mutex
));
TEST_ASSERT_EQUAL
(
0
,
res
);
res
=
memset_s
(
threads
,
sizeof
(
threads
),
0
,
sizeof
(
threads
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_init
(
&
pthreadAttr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
// init attr and cond and mutex
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_condattr_init
(
&
attr
));
LOGI
(
"pthread_condattr_init in TestConWait result = %d"
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_cond_init
(
&
cond
,
&
attr
));
LOGI
(
"pthread_cond_init in TestConWait result = %d"
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
ThreadTestArgs
args
=
{
.
cond
=
&
cond
,
.
mutex
=
&
mutex
,
.
condState
=
-
1
,
};
/* create phread to wait */
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_create
(
&
threads
[
i
],
&
pthreadAttr
,
ThreadCondWait
,
&
args
));
LOGI
(
"create pthread_cond_wait thread result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
int
sleepSeconds
=
rand
()
%
(
WAIT_IN_SEM_SECONDS_MAX
-
WAIT_IN_SEM_SECONDS_MIN
)
+
WAIT_IN_SEM_SECONDS_MIN
;
sleep
(
sleepSeconds
);
/* sleep seconds then create thread to send signal */
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_create
(
&
threads
[
i
],
&
pthreadAttr
,
ThreadCondSignal
,
&
args
));
LOGI
(
"create pthread_cond_signal thread result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
sleep
(
sleepSeconds
);
TEST_ASSERT_EQUAL
(
0
,
args
.
condState
);
}
}
/* pthread_cond_signal test */
static
void
TestConSignal
(
int
count
)
{
int
res
;
pthread_condattr_t
attr
=
{
0
};
pthread_cond_t
cond
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_cond_init
(
&
cond
,
&
attr
));
LOGI
(
"pthread_cond_init in TestConWait result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_cond_signal
(
&
cond
));
LOGI
(
"pthread_cond_signal result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
}
/* test semaphore with sem series */
void
TestHcSemCondition
(
void
)
{
TestSemInit
(
REQUIRED_SEM_DEFAULT_COUNT
);
TestSemPost
(
REQUIRED_SEM_DEFAULT_COUNT
);
TestSemWait
(
REQUIRED_SEM_DEFAULT_COUNT
);
}
/* test semaphore with phread cond */
void
TestHcPthreadCondition
(
void
)
{
TestConWait
(
REQUIRED_ATTR_DEFAULT_COUNT
);
TestAttrConInit
(
REQUIRED_ATTR_DEFAULT_COUNT
);
TestConInit
(
REQUIRED_ATTR_DEFAULT_COUNT
);
TestConSignal
(
REQUIRED_ATTR_DEFAULT_COUNT
);
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_condition_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_CONDITION_TEST_H
#define HC_CONDITION_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcSemCondition
(
void
);
void
TestHcPthreadCondition
(
void
);
#ifdef __cplusplus
}
#endif
enum
{
WAIT_IN_SEM_SECONDS_MIN
=
1
,
WAIT_IN_SEM_SECONDS_MAX
=
2
,
};
#endif // HC_CONDITION_TEST_H
\ No newline at end of file
security_lite/deviceauth_basic_deps/hc_dev_info_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_dev_info_test.h"
#include <hctest.h>
#include <parameter.h>
#include <pthread.h>
#include <securec.h>
#include <stdlib.h>
#include "print_log.h"
#include "test_timer.h"
#ifdef __cplusplus
extern
"C"
{
#endif
#define MAX_INPUT_UDID_LEN 200
enum
{
INPUT_UDID_LEN
=
65
,
TEST_UDID_TIMES
=
20
,
};
static
void
TestGetDevUdid
(
char
*
udid
,
int
len
)
{
int
res
;
int
zeroCount
=
0
;
res
=
memset_s
(
udid
,
MAX_INPUT_UDID_LEN
,
0
,
MAX_INPUT_UDID_LEN
);
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
GetDevUdid
(
udid
,
len
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
len
;
++
i
)
{
if
(
udid
[
i
]
==
0
)
{
++
zeroCount
;
}
}
TEST_ASSERT_NOT_EQUAL_MESSAGE
(
len
,
zeroCount
,
"invalid all zero udid"
);
}
void
TestHcGetUdid
(
void
)
{
int
res
;
char
udid
[
MAX_INPUT_UDID_LEN
]
=
{
0
};
int
udidLen
;
LOGI
(
"check rand size udid"
);
for
(
int
i
=
0
;
i
<
TEST_UDID_TIMES
;
++
i
)
{
udidLen
=
rand
()
%
(
MAX_INPUT_UDID_LEN
-
INPUT_UDID_LEN
)
+
INPUT_UDID_LEN
;
LOGI
(
"rand udidLen = %d"
,
udidLen
);
res
=
memset_s
(
udid
,
sizeof
(
udid
),
0
,
sizeof
(
udid
));
TEST_ASSERT_EQUAL
(
0
,
res
);
TestGetDevUdid
(
udid
,
udidLen
);
LOGI
(
"udid =
\"
%s
\"
"
,
udid
);
}
LOGI
(
"check min size udid"
);
res
=
memset_s
(
udid
,
sizeof
(
udid
),
0
,
sizeof
(
udid
));
TEST_ASSERT_EQUAL
(
0
,
res
);
TestGetDevUdid
(
udid
,
INPUT_UDID_LEN
);
LOGI
(
"udid =
\"
%s
\"
"
,
udid
);
LOGI
(
"check max size udid"
);
res
=
memset_s
(
udid
,
sizeof
(
udid
),
0
,
sizeof
(
udid
));
TEST_ASSERT_EQUAL
(
0
,
res
);
TestGetDevUdid
(
udid
,
MAX_INPUT_UDID_LEN
);
LOGI
(
"udid =
\"
%s
\"
"
,
udid
);
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_dev_info_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_DEV_INFO_TEST_H
#define HC_DEV_INFO_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcGetUdid
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_DEV_INFO_TEST_H
security_lite/deviceauth_basic_deps/hc_file_common.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_file_common.h"
#include <hctest.h>
#include <stdlib.h>
#ifdef __cplusplus
extern
"C"
{
#endif
char
*
GenerateTestingText
(
int
size
)
{
TEST_ASSERT_LESS_OR_EQUAL
(
TEN_KILOBYTE
,
size
);
char
*
text
=
(
char
*
)
malloc
(
size
+
1
);
if
(
text
==
NULL
)
{
return
NULL
;
}
for
(
int
i
=
0
;
i
<
size
;
i
++
)
{
text
[
i
]
=
rand
()
%
(
ASCII_END
-
ASCII_START
)
+
ASCII_START
;
}
text
[
size
]
=
0
;
return
text
;
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_file_common.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_FILE_COMMON_H
#define HC_FILE_COMMON_H
#ifdef __cplusplus
extern
"C"
{
#endif
#define TEST_FILE_NAME "test"
#define TEST_FILE_DIR "/testDir"
#define DEFAULT_FILE_PERMISSION 0644
#define ASCII_START 32
#define ASCII_END 126
#define ONE_BYTE 1
#define HALF_KILOBYTE 512
#define ONE_KILOBYTE 1024
#define TEN_KILOBYTE 10240
#define TEST_FILE_SIZE_LIST_LEN 4
static
const
int
testFileSizeList
[
TEST_FILE_SIZE_LIST_LEN
]
=
{
ONE_BYTE
,
HALF_KILOBYTE
,
ONE_KILOBYTE
,
TEN_KILOBYTE
};
char
*
GenerateTestingText
(
int
size
);
#ifdef __cplusplus
}
#endif
#endif // HC_FILE_COMMON_H
\ No newline at end of file
security_lite/deviceauth_basic_deps/hc_file_f_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_file_f_test.h"
#include <errno.h>
#include <fcntl.h>
#include <hctest.h>
#include <securec.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include "hc_file_common.h"
#include "print_log.h"
#include "test_timer.h"
#ifdef __cplusplus
extern
"C"
{
#endif
#if F_API_IMPLEMENTED
static
void
ReadFile
(
char
*
buffer
,
FILE
*
file
,
int
size
)
{
int
total
=
0
;
while
(
total
<
size
)
{
int
readCount
=
fread
(
buffer
+
total
,
1
,
size
-
total
,
file
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
readCount
);
TEST_ASSERT_LESS_OR_EQUAL
(
size
-
total
,
readCount
);
total
+=
readCount
;
if
(
readCount
<=
0
)
{
break
;
}
}
}
static
void
WriteFile
(
const
char
*
buffer
,
FILE
*
file
,
int
size
)
{
int
total
=
0
;
while
(
total
<
size
)
{
int
writeCount
=
fwrite
(
buffer
+
total
,
1
,
size
-
total
,
file
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
writeCount
);
TEST_ASSERT_LESS_OR_EQUAL
(
size
-
total
,
writeCount
);
total
+=
writeCount
;
if
(
writeCount
<=
0
)
{
break
;
}
}
}
static
void
TestHcFileFopenAndFclose
(
void
)
{
const
char
*
fileName
=
TEST_FILE_NAME
;
LOGI
(
"begin to open file: %s"
,
fileName
);
FILE
*
file
;
RUN_AND_PRINT_ELAPSED_TIME
(
file
,
fopen
(
fileName
,
"w+"
));
TEST_ASSERT_NOT_NULL
(
file
);
int
ret
;
LOGI
(
"begin to close file: %s"
,
fileName
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
fclose
(
file
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
static
void
TestHcFileFreadAndFwrite
(
void
)
{
const
char
*
fileName
=
TEST_FILE_NAME
;
for
(
int
i
=
0
;
i
<
TEST_FILE_SIZE_LIST_LEN
;
i
++
)
{
FILE
*
file
=
fopen
(
fileName
,
"w+"
);
TEST_ASSERT_NOT_NULL
(
file
);
int
size
=
testFileSizeList
[
i
];
LOGI
(
"begin to write file [%s] for size: %d"
,
fileName
,
size
);
char
*
writeBuffer
=
GenerateTestingText
(
size
);
TEST_ASSERT_NOT_NULL
(
writeBuffer
);
RUN_AND_PRINT_ELAPSED_TIME_WITHOUT_RESULT
(
WriteFile
(
writeBuffer
,
file
,
size
));
TEST_ASSERT_EQUAL
(
0
,
fseek
(
file
,
0
,
SEEK_END
));
const
int
fileSize
=
ftell
(
file
);
TEST_ASSERT_EQUAL
(
size
,
fileSize
);
TEST_ASSERT_EQUAL
(
0
,
fseek
(
file
,
0
,
SEEK_SET
));
LOGI
(
"begin to read file [%s] for size: %d"
,
fileName
,
fileSize
);
TEST_ASSERT_LESS_OR_EQUAL
(
TEN_KILOBYTE
,
fileSize
);
char
*
readBuffer
=
(
char
*
)
malloc
(
fileSize
+
1
);
TEST_ASSERT_NOT_NULL
(
readBuffer
);
TEST_ASSERT_EQUAL
(
0
,
memset_s
(
readBuffer
,
fileSize
+
1
,
0
,
fileSize
+
1
));
RUN_AND_PRINT_ELAPSED_TIME_WITHOUT_RESULT
(
ReadFile
(
readBuffer
,
file
,
fileSize
));
TEST_ASSERT_EQUAL_STRING
(
writeBuffer
,
readBuffer
);
free
(
readBuffer
);
free
(
writeBuffer
);
TEST_ASSERT_EQUAL
(
0
,
fclose
(
file
));
sleep
(
1
);
}
}
static
void
TestHcFileFseekAndFtell
(
void
)
{
const
char
*
fileName
=
TEST_FILE_NAME
;
LOGI
(
"begin to count file size"
);
FILE
*
file
=
fopen
(
fileName
,
"rb"
);
TEST_ASSERT_NOT_NULL
(
file
);
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
fseek
(
file
,
0
,
SEEK_END
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
int
size
;
RUN_AND_PRINT_ELAPSED_TIME
(
size
,
ftell
(
file
));
TEST_ASSERT_EQUAL
(
TEN_KILOBYTE
,
size
);
TEST_ASSERT_EQUAL
(
0
,
fseek
(
file
,
0
,
SEEK_SET
));
LOGI
(
"the file size is: %d"
,
size
);
TEST_ASSERT_EQUAL
(
0
,
fclose
(
file
));
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
unlink
(
fileName
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
static
void
TestHcFileMkdir
(
void
)
{
#if MKDIR_IMPLEMENTED
const
char
*
dir
=
TEST_FILE_DIR
;
LOGI
(
"begin to make directory: %s"
,
dir
);
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
mkdir
(
dir
,
DEFAULT_FILE_PERMISSION
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
TEST_ASSERT_EQUAL
(
-
1
,
mkdir
(
dir
,
DEFAULT_FILE_PERMISSION
));
TEST_ASSERT_EQUAL
(
0
,
rmdir
(
dir
));
#endif
}
static
void
TestHcFileStat
(
void
)
{
#if STAT_IMPLEMENTED
const
char
*
fileName
=
TEST_FILE_NAME
;
LOGI
(
"begin to check [%s] state"
,
fileName
);
FILE
*
file
=
fopen
(
fileName
,
"w+"
);
TEST_ASSERT_NOT_NULL
(
file
);
TEST_ASSERT_EQUAL
(
0
,
fclose
(
file
));
struct
stat
fileStat
;
int
ret
;
ret
=
memset_s
(
&
fileStat
,
sizeof
(
fileStat
),
0
,
sizeof
(
fileStat
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
stat
(
fileName
,
&
fileStat
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
TEST_ASSERT_EQUAL
(
0
,
unlink
(
fileName
));
ret
=
memset_s
(
&
fileStat
,
sizeof
(
fileStat
),
0
,
sizeof
(
fileStat
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
TEST_ASSERT_EQUAL
(
-
1
,
stat
(
fileName
,
&
fileStat
));
TEST_ASSERT_EQUAL
(
ENOENT
,
errno
);
#endif
}
static
void
TestHcFileRemove
(
void
)
{
const
char
*
fileName
=
TEST_FILE_NAME
;
LOGI
(
"begin to remove file: %s"
,
fileName
);
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
unlink
(
fileName
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
static
void
TestHcFileAccess
(
void
)
{
#if ACCESS_IMPLEMENTED
const
char
*
fileName
=
TEST_FILE_NAME
;
LOGI
(
"begin to check access of [%s]"
,
fileName
);
FILE
*
file
=
fopen
(
fileName
,
"w+"
);
TEST_ASSERT_NOT_NULL
(
file
);
TEST_ASSERT_EQUAL
(
0
,
fclose
(
file
));
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
access
(
fileName
,
F_OK
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
TEST_ASSERT_EQUAL
(
0
,
unlink
(
fileName
));
TEST_ASSERT_EQUAL
(
-
1
,
access
(
fileName
,
F_OK
));
#endif
}
void
TestHcFileFApi
(
void
)
{
LOGI
(
"test opening and closing file"
);
TestHcFileFopenAndFclose
();
LOGI
(
"test removing file"
);
TestHcFileRemove
();
LOGI
(
"test reading and writing file"
);
TestHcFileFreadAndFwrite
();
LOGI
(
"test counting file size"
);
TestHcFileFseekAndFtell
();
LOGI
(
"test making directory"
);
TestHcFileMkdir
();
LOGI
(
"test getting file state"
);
TestHcFileStat
();
LOGI
(
"test accessing a file"
);
TestHcFileAccess
();
}
#else // F_API_IMPLEMENTED
void
TestHcFileFApi
(
void
)
{
LOGE
(
"no F_API_IMPLEMENTED, do not test fopen series!"
);
}
#endif // F_API_IMPLEMENTED
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_file_f_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_FILE_F_TEST_H
#define HC_FILE_F_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcFileFApi
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_FILE_F_TEST_H
security_lite/deviceauth_basic_deps/hc_file_iot_flash_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_file_iot_flash_test.h"
#include <hctest.h>
#include <iot_errno.h>
#include <iot_flash.h>
#include <securec.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include "print_log.h"
#include "test_timer.h"
#ifdef __cplusplus
extern
"C"
{
#endif
#if FLASH_START_ADDRESS_HICHAIN
#define FLASH_SIZE_4_K 4096
#define TOTAL_STORAGE_SIZE FLASH_SIZE_4_K // 4K Bytes
#define GROUP_OFFSET_ADDR 0x0100 // sizeof(struct FlashHeader)
#define TCIS_OFFSET_ADDR 0x0BC0
#define KEY_OFFSET_ADDR 0x0DC0
#define PART2_OFFSET_ADDR 0x0EC0
#define PART3_OFFSET_ADDR 0x0F00
#define SALT_OFFSET_ADDR 0x0F40
#define MK_OFFSET_ADDR 0x0F80
#define MAGIC_NUM 0x07DECADE
#define DEFAULT_VERSION 0x01
typedef
enum
FileIdEnumT
{
FILE_ID_GROUP
=
0
,
FILE_ID_TCIS_DATA
,
FILE_ID_KEYCONTENT
,
FILE_ID_PART2
,
FILE_ID_PART3
,
FILE_ID_SALT
,
FILE_ID_MK
,
FILE_ID_LAST
,
}
FileIdEnum
;
static
uint32_t
g_startAddr
=
FLASH_START_ADDRESS_HICHAIN
;
static
const
struct
FlashHeader
{
struct
VersionHeader
{
uint64_t
magic
;
uint16_t
version
;
uint8_t
reserved
[
54
];
// 54: Reserved bytes for expansion
}
versionHeader
;
struct
FileHeader
{
uint32_t
start
;
uint32_t
size
;
uint32_t
end
;
}
fileHeaders
[
FILE_ID_LAST
];
uint8_t
reserved
[
108
];
// 108: Reserved bytes for expansion
}
g_flashHeader
=
{
.
versionHeader
=
{
.
magic
=
MAGIC_NUM
,
.
version
=
DEFAULT_VERSION
,
},
.
fileHeaders
[
FILE_ID_GROUP
]
=
{
.
start
=
GROUP_OFFSET_ADDR
,
.
size
=
TCIS_OFFSET_ADDR
-
GROUP_OFFSET_ADDR
,
.
end
=
TCIS_OFFSET_ADDR
,
},
.
fileHeaders
[
FILE_ID_TCIS_DATA
]
=
{
.
start
=
TCIS_OFFSET_ADDR
,
.
size
=
KEY_OFFSET_ADDR
-
TCIS_OFFSET_ADDR
,
.
end
=
KEY_OFFSET_ADDR
,
},
.
fileHeaders
[
FILE_ID_KEYCONTENT
]
=
{
.
start
=
KEY_OFFSET_ADDR
,
.
size
=
PART2_OFFSET_ADDR
-
KEY_OFFSET_ADDR
,
.
end
=
PART2_OFFSET_ADDR
,
},
.
fileHeaders
[
FILE_ID_PART2
]
=
{
.
start
=
PART2_OFFSET_ADDR
,
.
size
=
PART3_OFFSET_ADDR
-
PART2_OFFSET_ADDR
,
.
end
=
PART3_OFFSET_ADDR
,
},
.
fileHeaders
[
FILE_ID_PART3
]
=
{
.
start
=
PART3_OFFSET_ADDR
,
.
size
=
SALT_OFFSET_ADDR
-
PART3_OFFSET_ADDR
,
.
end
=
SALT_OFFSET_ADDR
,
},
.
fileHeaders
[
FILE_ID_SALT
]
=
{
.
start
=
SALT_OFFSET_ADDR
,
.
size
=
MK_OFFSET_ADDR
-
SALT_OFFSET_ADDR
,
.
end
=
MK_OFFSET_ADDR
,
},
.
fileHeaders
[
FILE_ID_MK
]
=
{
.
start
=
MK_OFFSET_ADDR
,
.
size
=
TOTAL_STORAGE_SIZE
-
MK_OFFSET_ADDR
,
.
end
=
TOTAL_STORAGE_SIZE
,
},
};
enum
{
RANDOM_READ_TIMES
=
20
,
};
static
void
ReadFlash
(
uint32_t
offset
,
uint8_t
*
buffer
,
uint32_t
size
)
{
int
res
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
IoTFlashInit
());
TEST_ASSERT_EQUAL
(
IOT_SUCCESS
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
IoTFlashRead
(
g_startAddr
+
offset
,
size
,
buffer
));
TEST_ASSERT_EQUAL
(
IOT_SUCCESS
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
IoTFlashDeinit
());
TEST_ASSERT_EQUAL
(
IOT_SUCCESS
,
res
);
}
static
void
WriteFlash
(
uint32_t
offset
,
const
uint8_t
*
buffer
,
uint32_t
size
)
{
int
res
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
IoTFlashInit
());
TEST_ASSERT_EQUAL
(
IOT_SUCCESS
,
res
);
LOGI
(
"begin write, g_startAddr + offset = %lu, size = %lu, buffer = %p"
,
(
unsigned
long
)(
g_startAddr
+
offset
),
(
unsigned
long
)(
size
),
buffer
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
IoTFlashWrite
(
g_startAddr
+
offset
,
size
,
buffer
,
true
));
TEST_ASSERT_EQUAL
(
IOT_SUCCESS
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
IoTFlashDeinit
());
TEST_ASSERT_EQUAL
(
IOT_SUCCESS
,
res
);
}
static
void
TestIotFlashWrite
(
const
uint8_t
*
totalDataContent
,
uint32_t
sz
)
{
LOGI
(
"begin to test writing flash"
);
WriteFlash
(
0
,
totalDataContent
,
sz
);
LOGI
(
"test writing flash done"
);
}
static
void
TestIotFlashReadWholeBlock
(
uint8_t
*
totalData
,
uint32_t
sz
,
const
uint8_t
*
totalDataContent
,
uint32_t
contentSz
)
{
int
res
=
memset_s
(
totalData
,
sz
,
0
,
sz
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
LOGI
(
"begin to test read whole flash"
);
ReadFlash
(
0
,
totalData
,
sz
);
LOGI
(
"test reading whole flash done"
);
TEST_ASSERT_EQUAL
(
sz
,
contentSz
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
totalData
,
totalDataContent
,
sz
);
}
static
void
TestIotFlashReadFlashHeader
(
struct
FlashHeader
*
flashHeader
,
const
struct
FlashHeader
*
flashHeaderCompare
)
{
int
res
=
memset_s
(
flashHeader
,
sizeof
(
*
flashHeader
),
0
,
sizeof
(
*
flashHeader
));
TEST_ASSERT_EQUAL
(
EOK
,
res
);
LOGI
(
"begin reading header"
);
ReadFlash
(
0
,
(
uint8_t
*
)
flashHeader
,
sizeof
(
struct
FlashHeader
));
LOGI
(
"end reading header"
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
((
const
uint8_t
*
)
flashHeader
,
(
const
uint8_t
*
)
flashHeaderCompare
,
sizeof
(
struct
FlashHeader
));
}
static
void
TestIotFlashReadSmallFiles
(
uint8_t
*
totalData
,
uint32_t
sz
,
const
uint8_t
*
totalDataContent
,
uint32_t
contentSz
)
{
LOGI
(
"begin reading small files"
);
TEST_ASSERT_EQUAL
((
uint32_t
)(
TOTAL_STORAGE_SIZE
),
contentSz
);
int
res
;
for
(
int
i
=
0
;
i
<
FILE_ID_LAST
;
++
i
)
{
LOGI
(
"test flash file %d/%d"
,
i
,
FILE_ID_LAST
);
res
=
memset_s
(
totalData
,
sz
,
0
,
sz
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
LOGI
(
"test read from %lu, size %lu"
,
(
unsigned
long
)(
g_flashHeader
.
fileHeaders
[
i
].
start
),
(
unsigned
long
)(
g_flashHeader
.
fileHeaders
[
i
].
size
));
ReadFlash
(
g_flashHeader
.
fileHeaders
[
i
].
start
,
totalData
,
g_flashHeader
.
fileHeaders
[
i
].
size
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
totalData
,
totalDataContent
+
g_flashHeader
.
fileHeaders
[
i
].
start
,
g_flashHeader
.
fileHeaders
[
i
].
size
);
}
LOGI
(
"end reading small files"
);
}
static
void
TestIotFlashReadRandom
(
uint8_t
*
totalData
,
uint32_t
sz
,
const
uint8_t
*
totalDataContent
,
uint32_t
contentSz
)
{
LOGI
(
"begin reading random bytes"
);
TEST_ASSERT_EQUAL
((
uint32_t
)(
TOTAL_STORAGE_SIZE
),
contentSz
);
int
res
;
for
(
int
i
=
0
;
i
<
RANDOM_READ_TIMES
;
++
i
)
{
uint32_t
startAddr
=
rand
()
%
TOTAL_STORAGE_SIZE
;
uint32_t
size
=
rand
()
%
(
TOTAL_STORAGE_SIZE
-
startAddr
);
LOGI
(
"test random read flash %d/%d, startAddr = %lu, size = %lu"
,
i
,
RANDOM_READ_TIMES
,
(
unsigned
long
)(
startAddr
),
(
unsigned
long
)(
size
));
res
=
memset_s
(
totalData
,
sz
,
0
,
sz
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
ReadFlash
(
startAddr
,
totalData
,
size
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
totalData
,
totalDataContent
+
startAddr
,
size
);
}
LOGI
(
"end reading random bytes"
);
LOGI
(
"begin reading small bytes"
);
for
(
int
i
=
0
;
i
<
RANDOM_READ_TIMES
;
++
i
)
{
uint32_t
size
=
i
+
1
;
uint32_t
startAddr
=
rand
()
%
(
TOTAL_STORAGE_SIZE
-
size
);
LOGI
(
"test random read flash %d/%d, startAddr = %lu, size = %lu"
,
i
,
RANDOM_READ_TIMES
,
(
unsigned
long
)(
startAddr
),
(
unsigned
long
)(
size
));
res
=
memset_s
(
totalData
,
sz
,
0
,
sz
);
TEST_ASSERT_EQUAL
(
EOK
,
res
);
ReadFlash
(
startAddr
,
totalData
,
size
);
TEST_ASSERT_EQUAL_HEX8_ARRAY
(
totalData
,
totalDataContent
+
startAddr
,
size
);
}
LOGI
(
"end reading small bytes"
);
}
void
TestHcFileIotFlash
(
void
)
{
uint8_t
*
totalData
=
(
uint8_t
*
)
malloc
(
TOTAL_STORAGE_SIZE
);
TEST_ASSERT_NOT_NULL
(
totalData
);
uint8_t
*
totalDataContent
=
(
uint8_t
*
)
malloc
(
TOTAL_STORAGE_SIZE
);
TEST_ASSERT_NOT_NULL
(
totalDataContent
);
LOGI
(
"malloc memory succeed"
);
int
res
,
zeroCount
=
0
;
struct
FlashHeader
flashHeader
;
res
=
memset_s
(
&
flashHeader
,
sizeof
(
flashHeader
),
0
,
sizeof
(
flashHeader
));
TEST_ASSERT_EQUAL
(
EOK
,
res
);
for
(
uint32_t
i
=
0
;
i
<
TOTAL_STORAGE_SIZE
;
++
i
)
{
totalDataContent
[
i
]
=
rand
()
%
UINT8_MAX
;
if
(
totalDataContent
[
i
]
==
0
)
{
++
zeroCount
;
}
}
TEST_ASSERT_NOT_EQUAL
(
TOTAL_STORAGE_SIZE
,
zeroCount
);
TestIotFlashWrite
(
totalDataContent
,
TOTAL_STORAGE_SIZE
);
TestIotFlashReadWholeBlock
(
totalData
,
TOTAL_STORAGE_SIZE
,
totalDataContent
,
TOTAL_STORAGE_SIZE
);
TestIotFlashReadFlashHeader
(
&
flashHeader
,
(
struct
FlashHeader
*
)
totalDataContent
);
TestIotFlashReadSmallFiles
(
totalData
,
TOTAL_STORAGE_SIZE
,
totalDataContent
,
TOTAL_STORAGE_SIZE
);
TestIotFlashReadRandom
(
totalData
,
TOTAL_STORAGE_SIZE
,
totalDataContent
,
TOTAL_STORAGE_SIZE
);
free
(
totalData
);
free
(
totalDataContent
);
}
#else // FLASH_START_ADDRESS_HICHAIN
void
TestHcFileIotFlash
(
void
)
{
LOGE
(
"no FLASH_START_ADDRESS_HICHAIN, do not test iot flash"
);
}
#endif // FLASH_START_ADDRESS_HICHAIN
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_file_iot_flash_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_FILE_IOT_FLASH_TEST_H
#define HC_FILE_IOT_FLASH_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcFileIotFlash
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_FILE_IOT_FLASH_TEST_H
security_lite/deviceauth_basic_deps/hc_file_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_file_test.h"
#include <errno.h>
#include <fcntl.h>
#include <hctest.h>
#include <securec.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "hc_file_common.h"
#include "print_log.h"
#include "test_timer.h"
#ifdef __cplusplus
extern
"C"
{
#endif
#if TEST_HC_FILE_OPEN_SERIES
static
void
ReadFile
(
char
*
buffer
,
int
fd
,
int
size
)
{
int
total
=
0
;
while
(
total
<
size
)
{
int
readCount
=
read
(
fd
,
buffer
+
total
,
size
-
total
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
readCount
);
TEST_ASSERT_LESS_OR_EQUAL
(
size
-
total
,
readCount
);
total
+=
readCount
;
if
(
readCount
<=
0
)
{
break
;
}
}
}
static
void
WriteFile
(
char
*
buffer
,
int
fd
,
int
size
)
{
int
total
=
0
;
while
(
total
<
size
)
{
int
writeCount
=
write
(
fd
,
buffer
+
total
,
size
-
total
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
writeCount
);
TEST_ASSERT_LESS_OR_EQUAL
(
size
-
total
,
writeCount
);
total
+=
writeCount
;
if
(
writeCount
<=
0
)
{
break
;
}
}
}
static
void
TestHcFileOpenAndClose
(
void
)
{
const
char
*
file
=
TEST_FILE_NAME
;
LOGI
(
"begin to open file: %s"
,
file
);
int
fd
;
RUN_AND_PRINT_ELAPSED_TIME
(
fd
,
open
(
file
,
O_RDWR
|
O_CREAT
));
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
fd
);
int
ret
;
LOGI
(
"begin to close file: %s"
,
file
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
close
(
fd
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
static
void
TestHcFileReadAndWrite
(
void
)
{
const
char
*
file
=
TEST_FILE_NAME
;
for
(
int
i
=
0
;
i
<
TEST_FILE_SIZE_LIST_LEN
;
i
++
)
{
int
fd
=
open
(
file
,
O_RDWR
|
O_CREAT
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
fd
);
int
size
=
testFileSizeList
[
i
];
LOGI
(
"begin to write file [%s] for size: %d"
,
file
,
size
);
char
*
writeBuffer
=
GenerateTestingText
(
size
);
TEST_ASSERT_NOT_NULL
(
writeBuffer
);
RUN_AND_PRINT_ELAPSED_TIME_WITHOUT_RESULT
(
WriteFile
(
writeBuffer
,
fd
,
size
));
const
int
fileSize
=
lseek
(
fd
,
0
,
SEEK_END
);
TEST_ASSERT_EQUAL
(
size
,
fileSize
);
TEST_ASSERT_EQUAL
(
0
,
lseek
(
fd
,
0
,
SEEK_SET
));
LOGI
(
"begin to read file [%s] for size: %d"
,
file
,
fileSize
);
TEST_ASSERT_LESS_OR_EQUAL
(
TEN_KILOBYTE
,
fileSize
);
char
*
readBuffer
=
(
char
*
)
malloc
(
fileSize
+
1
);
TEST_ASSERT_NOT_NULL
(
readBuffer
);
TEST_ASSERT_EQUAL
(
0
,
memset_s
(
readBuffer
,
fileSize
+
1
,
0
,
fileSize
+
1
));
RUN_AND_PRINT_ELAPSED_TIME_WITHOUT_RESULT
(
ReadFile
(
readBuffer
,
fd
,
fileSize
));
TEST_ASSERT_EQUAL_STRING
(
writeBuffer
,
readBuffer
);
free
(
readBuffer
);
free
(
writeBuffer
);
TEST_ASSERT_EQUAL
(
0
,
close
(
fd
));
sleep
(
1
);
}
}
static
void
TestHcFileSize
(
void
)
{
const
char
*
file
=
TEST_FILE_NAME
;
LOGI
(
"begin to count file size"
);
int
fd
=
open
(
file
,
O_RDWR
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
fd
);
int
size
;
RUN_AND_PRINT_ELAPSED_TIME
(
size
,
lseek
(
fd
,
0
,
SEEK_END
));
TEST_ASSERT_EQUAL
(
TEN_KILOBYTE
,
size
);
TEST_ASSERT_EQUAL
(
0
,
lseek
(
fd
,
0
,
SEEK_SET
));
LOGI
(
"the file size is: %d"
,
size
);
TEST_ASSERT_EQUAL
(
0
,
close
(
fd
));
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
unlink
(
file
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
static
void
TestHcFileMkdir
(
void
)
{
#if MKDIR_IMPLEMENTED
const
char
*
dir
=
TEST_FILE_DIR
;
LOGI
(
"begin to make directory: %s"
,
dir
);
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
mkdir
(
dir
,
DEFAULT_FILE_PERMISSION
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
TEST_ASSERT_EQUAL
(
-
1
,
mkdir
(
dir
,
DEFAULT_FILE_PERMISSION
));
TEST_ASSERT_EQUAL
(
0
,
rmdir
(
dir
));
#else
LOGE
(
"no MKDIR_IMPLEMENTED, do not test mkdir() !"
);
#endif
}
static
void
TestHcFileStat
(
void
)
{
#if STAT_IMPLEMENTED
const
char
*
file
=
TEST_FILE_NAME
;
LOGI
(
"begin to check [%s] state"
,
file
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
open
(
file
,
O_RDWR
|
O_CREAT
));
struct
stat
fileStat
;
int
ret
;
ret
=
memset_s
(
&
fileStat
,
sizeof
(
fileStat
),
0
,
sizeof
(
fileStat
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
stat
(
file
,
&
fileStat
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
TEST_ASSERT_EQUAL
(
0
,
unlink
(
file
));
ret
=
memset_s
(
&
fileStat
,
sizeof
(
fileStat
),
0
,
sizeof
(
fileStat
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
TEST_ASSERT_EQUAL
(
-
1
,
stat
(
file
,
&
fileStat
));
TEST_ASSERT_EQUAL
(
ENOENT
,
errno
);
#else
LOGE
(
"no STAT_IMPLEMENTED, do not test stat() !"
);
#endif
}
static
void
TestHcFileRemove
(
void
)
{
const
char
*
file
=
TEST_FILE_NAME
;
LOGI
(
"begin to remove file: %s"
,
file
);
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
unlink
(
file
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
void
TestHcFile
(
void
)
{
LOGI
(
"test opening and closing file"
);
TestHcFileOpenAndClose
();
LOGI
(
"test removing file"
);
TestHcFileRemove
();
LOGI
(
"test reading and writing file"
);
TestHcFileReadAndWrite
();
LOGI
(
"test counting file size"
);
TestHcFileSize
();
LOGI
(
"test making directory"
);
TestHcFileMkdir
();
LOGI
(
"test getting file state"
);
TestHcFileStat
();
}
#else // TEST_HC_FILE_OPEN_SERIES
void
TestHcFile
(
void
)
{
LOGE
(
"no TEST_HC_FILE_OPEN_SERIES, do not test hc_file open series!"
);
}
#endif // TEST_HC_FILE_OPEN_SERIES
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_file_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_LINUX_FILE_TEST_H
#define HC_LINUX_FILE_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcFile
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_LINUX_FILE_TEST_H
security_lite/deviceauth_basic_deps/hc_file_utils_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_file_utils_test.h"
#include <hctest.h>
#include <securec.h>
#include <stdlib.h>
#include <unistd.h>
#include "hc_file_common.h"
#include "print_log.h"
#include "test_timer.h"
#include "utils_file.h"
#ifdef __cplusplus
extern
"C"
{
#endif
#if UTILS_FILE_IMPLEMENTED
static
void
TestHcFileUtilsFileOpenAndUtilsFileClose
(
void
)
{
const
char
*
fileName
=
TEST_FILE_NAME
;
LOGI
(
"begin to open file: %s"
,
fileName
);
int
fd
;
TEST_ASSERT_EQUAL
(
-
1
,
UtilsFileOpen
(
fileName
,
O_RDONLY_FS
,
0
));
RUN_AND_PRINT_ELAPSED_TIME
(
fd
,
UtilsFileOpen
(
fileName
,
O_RDONLY_FS
|
O_CREAT_FS
,
0
));
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
fd
);
int
ret
;
LOGI
(
"begin to close file: %s"
,
fileName
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
UtilsFileClose
(
fd
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
static
void
TestHcFileUtilsFileReadAndFileWrite
(
void
)
{
const
char
*
fileName
=
TEST_FILE_NAME
;
for
(
int
i
=
0
;
i
<
TEST_FILE_SIZE_LIST_LEN
;
i
++
)
{
int
fd
=
UtilsFileOpen
(
fileName
,
O_RDWR_FS
|
O_CREAT_FS
,
0
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
fd
);
unsigned
int
size
=
testFileSizeList
[
i
];
LOGI
(
"begin to write file [%s] for size: %d"
,
fileName
,
size
);
char
*
writeBuffer
=
GenerateTestingText
(
size
);
TEST_ASSERT_NOT_NULL
(
writeBuffer
);
RUN_AND_PRINT_ELAPSED_TIME_WITHOUT_RESULT
(
UtilsFileWrite
(
fd
,
writeBuffer
,
size
));
TEST_ASSERT_EQUAL
(
0
,
UtilsFileClose
(
fd
));
fd
=
UtilsFileOpen
(
fileName
,
O_RDWR_FS
|
O_CREAT_FS
,
0
);
TEST_ASSERT_GREATER_OR_EQUAL
(
0
,
fd
);
unsigned
int
fileSize
;
TEST_ASSERT_EQUAL
(
0
,
UtilsFileStat
(
fileName
,
&
fileSize
));
TEST_ASSERT_EQUAL
(
size
,
fileSize
);
LOGI
(
"begin to read file [%s] for size: %d"
,
fileName
,
fileSize
);
char
*
readBuffer
=
(
char
*
)
malloc
(
fileSize
+
1
);
TEST_ASSERT_NOT_NULL
(
readBuffer
);
TEST_ASSERT_EQUAL
(
0
,
memset_s
(
readBuffer
,
fileSize
+
1
,
0
,
fileSize
+
1
));
RUN_AND_PRINT_ELAPSED_TIME_WITHOUT_RESULT
(
UtilsFileRead
(
fd
,
readBuffer
,
fileSize
));
TEST_ASSERT_EQUAL_STRING
(
writeBuffer
,
readBuffer
);
free
(
readBuffer
);
free
(
writeBuffer
);
TEST_ASSERT_EQUAL
(
0
,
UtilsFileClose
(
fd
));
sleep
(
1
);
}
}
static
void
TestHcFileUtilsFileSize
(
void
)
{
const
char
*
fileName
=
TEST_FILE_NAME
;
LOGI
(
"begin to count file size"
);
unsigned
int
size
;
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
UtilsFileStat
(
fileName
,
&
size
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
TEST_ASSERT_EQUAL
(
TEN_KILOBYTE
,
size
);
LOGI
(
"the file size is: %d"
,
size
);
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
UtilsFileDelete
(
fileName
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
static
void
TestHcFileUtilsFileDelete
(
void
)
{
const
char
*
fileName
=
TEST_FILE_NAME
;
LOGI
(
"begin to remove file: %s"
,
fileName
);
int
ret
;
RUN_AND_PRINT_ELAPSED_TIME
(
ret
,
UtilsFileDelete
(
fileName
));
TEST_ASSERT_EQUAL
(
0
,
ret
);
}
void
TestHcFileUtilsFile
(
void
)
{
LOGI
(
"test opening and closing file"
);
TestHcFileUtilsFileOpenAndUtilsFileClose
();
LOGI
(
"test removing file"
);
TestHcFileUtilsFileDelete
();
LOGI
(
"test reading and writing file"
);
TestHcFileUtilsFileReadAndFileWrite
();
LOGI
(
"test counting file size"
);
TestHcFileUtilsFileSize
();
}
#else // UTILS_FILE_IMPLEMENTED
void
TestHcFileUtilsFile
(
void
)
{
LOGE
(
"no UTILS_FILE_IMPLEMENTED, do not test utils file!"
);
}
#endif // UTILS_FILE_IMPLEMENTED
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_file_utils_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_FILE_UTILS_TEST_H
#define HC_FILE_UTILS_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcFileUtilsFile
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_FILE_UTILS_TEST_H
security_lite/deviceauth_basic_deps/hc_mutex_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_mutex_test.h"
#include <hctest.h>
#include <pthread.h>
#include <securec.h>
#include <unistd.h>
#include "hc_thread_mutex_share.h"
#include "print_log.h"
#include "test_timer.h"
#ifdef __cplusplus
extern
"C"
{
#endif
#define REQUIRED_MUTEX_COUNT 20
static
void
TestSpecifiedCount
(
int
count
)
{
pthread_mutex_t
mutexes
[
REQUIRED_MUTEX_COUNT
];
int
res
;
TEST_ASSERT_GREATER_THAN
(
0
,
count
);
TEST_ASSERT_LESS_OR_EQUAL
(
REQUIRED_MUTEX_COUNT
,
count
);
res
=
memset_s
(
mutexes
,
sizeof
(
mutexes
),
0
,
sizeof
(
mutexes
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_mutex_init
(
&
mutexes
[
i
],
NULL
));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_mutex_lock
(
&
mutexes
[
i
]));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_mutex_unlock
(
&
mutexes
[
i
]));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_mutex_destroy
(
&
mutexes
[
i
]));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
}
static
void
*
MutexThreadRoutine
(
void
*
args
)
{
pthread_mutex_t
*
mtx
=
(
pthread_mutex_t
*
)
args
;
TEST_ASSERT_NOT_NULL
(
mtx
);
unsigned
long
long
timeConsumingResult
;
int
res
;
int
sleepSeconds
=
rand
()
%
(
WAIT_IN_MUTEX_SECONDS_MAX
-
WAIT_IN_MUTEX_SECONDS_MIN
)
+
WAIT_IN_MUTEX_SECONDS_MIN
;
LOGI
(
"in thread begin phase 1 work"
);
RUN_AND_PRINT_ELAPSED_TIME
(
timeConsumingResult
,
TimeConsumingOperation
());
LOGI
(
"in thread begin wait for mutex"
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_mutex_lock
(
mtx
));
TEST_ASSERT_EQUAL
(
0
,
res
);
LOGI
(
"in thread wait for mutex succeed"
);
LOGI
(
"in thread begin wait for %d seconds"
,
sleepSeconds
);
sleep
(
sleepSeconds
);
LOGI
(
"in thread wait for %d seconds succeed"
,
sleepSeconds
);
LOGI
(
"in thread begin phase 2 work"
);
RUN_AND_PRINT_ELAPSED_TIME
(
timeConsumingResult
,
TimeConsumingOperation
());
LOGI
(
"in thread begin release mutex"
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_mutex_unlock
(
mtx
));
TEST_ASSERT_EQUAL
(
0
,
res
);
LOGI
(
"in thread release mutex successfully"
);
LOGI
(
"in thread begin phase 3 work"
);
RUN_AND_PRINT_ELAPSED_TIME
(
timeConsumingResult
,
TimeConsumingOperation
());
(
void
)(
timeConsumingResult
);
LOGI
(
"in thread all work done"
);
return
mtx
;
}
static
void
TestMutexInThreads
(
void
)
{
pthread_mutex_t
mtx
;
pthread_attr_t
attr
;
int
res
;
pthread_t
threads
[
REQUIRED_THREAD_COUNT
];
res
=
memset_s
(
&
mtx
,
sizeof
(
mtx
),
0
,
sizeof
(
mtx
));
TEST_ASSERT_EQUAL
(
0
,
res
);
res
=
memset_s
(
&
attr
,
sizeof
(
attr
),
0
,
sizeof
(
attr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
res
=
memset_s
(
&
threads
,
sizeof
(
threads
),
0
,
sizeof
(
threads
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_mutex_init
(
&
mtx
,
NULL
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_init
(
&
attr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_setdetachstate
(
&
attr
,
PTHREAD_CREATE_JOINABLE
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_setstacksize
(
&
attr
,
MAX_THREAD_STACK_SIZE
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
REQUIRED_THREAD_COUNT
;
++
i
)
{
LOGI
(
"test threads %d/%d"
,
i
,
REQUIRED_THREAD_COUNT
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_create
(
&
threads
[
i
],
&
attr
,
MutexThreadRoutine
,
&
mtx
));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
REQUIRED_THREAD_COUNT
;
++
i
)
{
LOGI
(
"test threads %d/%d"
,
i
,
REQUIRED_THREAD_COUNT
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_join
(
threads
[
i
],
NULL
));
LOGI
(
"pthread_join result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_destroy
(
&
attr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
void
TestHcMutex
(
void
)
{
LOGI
(
"test one mutex"
);
TestSpecifiedCount
(
1
);
LOGI
(
"test %d mutexes"
,
REQUIRED_MUTEX_COUNT
);
TestSpecifiedCount
(
REQUIRED_MUTEX_COUNT
);
LOGI
(
"test mutexes in threads"
);
TestMutexInThreads
();
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_mutex_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_MUTEX_TEST_H
#define HC_MUTEX_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcMutex
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_MUTEX_TEST_H
security_lite/deviceauth_basic_deps/hc_thread_mutex_share.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_THREAD_MUTEX_SHARE_H
#define HC_THREAD_MUTEX_SHARE_H
#define REQUIRED_THREAD_COUNT 5
#define MAX_THREAD_STACK_SIZE 4096
#define MIN_THREAD_STACK_SIZE 4096
enum
{
WAIT_IN_MUTEX_SECONDS_MIN
=
3
,
WAIT_IN_MUTEX_SECONDS_MAX
=
5
,
};
#endif // HC_THREAD_MUTEX_SHARE_H
security_lite/deviceauth_basic_deps/hc_thread_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_thread_test.h"
#include <hctest.h>
#include <pthread.h>
#include <securec.h>
#include <stdlib.h>
#include <unistd.h>
#include "hc_thread_mutex_share.h"
#include "print_log.h"
#include "test_timer.h"
#ifdef __cplusplus
extern
"C"
{
#endif
#define REQUIRED_PTHREAD_ATTR_COUNT 20
#define TEST_STRING "hello"
typedef
struct
{
void
*
(
*
function
)(
void
*
);
size_t
sz
;
int
i
;
char
*
str
;
}
ThreadTestArgs
;
static
void
*
ThreadRountine
(
void
*
args
)
{
TEST_ASSERT_NOT_NULL
(
args
);
ThreadTestArgs
*
testArgs
=
(
ThreadTestArgs
*
)
args
;
int
sleepSeconds
=
rand
()
%
(
WAIT_IN_MUTEX_SECONDS_MAX
-
WAIT_IN_MUTEX_SECONDS_MIN
)
+
WAIT_IN_MUTEX_SECONDS_MIN
;
TEST_ASSERT_EQUAL
((
void
*
)
ThreadRountine
,
(
void
*
)
testArgs
->
function
);
TEST_ASSERT_EQUAL
((
size_t
)
MAX_THREAD_STACK_SIZE
,
testArgs
->
sz
);
TEST_ASSERT_GREATER_OR_EQUAL
(
MIN_THREAD_STACK_SIZE
,
testArgs
->
i
);
TEST_ASSERT_LESS_OR_EQUAL
(
MAX_THREAD_STACK_SIZE
,
testArgs
->
i
);
TEST_ASSERT_EQUAL_STRING
(
TEST_STRING
,
testArgs
->
str
);
LOGI
(
"test thread begin wait for %d seconds"
,
sleepSeconds
);
sleep
(
sleepSeconds
);
LOGI
(
"test thread wait for %d seconds successfully"
,
sleepSeconds
);
LOGI
(
"begin time consuming operation"
);
unsigned
long
long
res
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
TimeConsumingOperation
());
LOGI
(
"end time consuming operation, res = %llu"
,
res
);
return
args
;
}
static
int
GetStackSize
(
void
)
{
// use macro instead of enum to avoid error: division by zero [-Werror=div-by-zero]
#if (MAX_THREAD_STACK_SIZE == MIN_THREAD_STACK_SIZE)
return
MIN_THREAD_STACK_SIZE
;
#else
int
stackSize
=
rand
()
%
(
MAX_THREAD_STACK_SIZE
-
MIN_THREAD_STACK_SIZE
)
+
MIN_THREAD_STACK_SIZE
;
LOGI
(
"rand stack size = %d"
,
stackSize
);
return
stackSize
;
#endif
}
static
void
TestSpecifiedCount
(
int
count
,
int
detachState
)
{
TEST_ASSERT_GREATER_THAN
(
0
,
count
);
TEST_ASSERT_LESS_OR_EQUAL
(
REQUIRED_THREAD_COUNT
,
count
);
TEST_ASSERT_TRUE_MESSAGE
(
detachState
==
PTHREAD_CREATE_JOINABLE
||
detachState
==
PTHREAD_CREATE_DETACHED
,
"invalid detach state"
);
pthread_attr_t
attr
;
pthread_t
threads
[
REQUIRED_THREAD_COUNT
];
int
res
,
stackSize
;
static
ThreadTestArgs
args
=
{
.
function
=
ThreadRountine
,
.
sz
=
MAX_THREAD_STACK_SIZE
,
.
i
=
-
1
,
.
str
=
(
char
*
)
TEST_STRING
,
};
res
=
memset_s
(
threads
,
sizeof
(
threads
),
0
,
sizeof
(
threads
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_init
(
&
attr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_setdetachstate
(
&
attr
,
detachState
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
LOGI
(
"test thread %d/%d"
,
i
,
count
);
stackSize
=
GetStackSize
();
LOGI
(
"rand stack size = %d"
,
stackSize
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_setstacksize
(
&
attr
,
stackSize
));
TEST_ASSERT_EQUAL
(
0
,
res
);
args
.
i
=
stackSize
;
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_create
(
&
threads
[
i
],
&
attr
,
ThreadRountine
,
&
args
));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
if
(
detachState
==
PTHREAD_CREATE_JOINABLE
)
{
for
(
int
i
=
0
;
i
<
count
;
++
i
)
{
LOGI
(
"test thread %d/%d"
,
i
,
count
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_join
(
threads
[
i
],
NULL
));
LOGI
(
"pthread_join result = %d"
,
res
);
TEST_ASSERT_EQUAL
(
0
,
res
);
}
}
else
{
LOGI
(
"detachState is PTHREAD_CREATE_DETACHED, do not test pthread_join"
);
}
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_destroy
(
&
attr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
static
void
TestPthreadAttr
(
int
detachState
)
{
TEST_ASSERT_TRUE_MESSAGE
(
detachState
==
PTHREAD_CREATE_JOINABLE
||
detachState
==
PTHREAD_CREATE_DETACHED
,
"invalid detach state"
);
int
res
,
stackSize
;
pthread_attr_t
attr
[
REQUIRED_PTHREAD_ATTR_COUNT
];
res
=
memset_s
(
attr
,
sizeof
(
attr
),
0
,
sizeof
(
attr
));
TEST_ASSERT_EQUAL
(
0
,
res
);
for
(
int
i
=
0
;
i
<
REQUIRED_PTHREAD_ATTR_COUNT
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_init
(
&
attr
[
i
]));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_setdetachstate
(
&
attr
[
i
],
detachState
));
TEST_ASSERT_EQUAL
(
0
,
res
);
stackSize
=
GetStackSize
();
LOGI
(
"rand stack size = %d"
,
stackSize
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_setstacksize
(
&
attr
[
i
],
stackSize
));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
for
(
int
i
=
0
;
i
<
REQUIRED_PTHREAD_ATTR_COUNT
;
++
i
)
{
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
pthread_attr_destroy
(
&
attr
[
i
]));
TEST_ASSERT_EQUAL
(
0
,
res
);
}
}
static
void
TestState
(
int
detachState
)
{
TEST_ASSERT_TRUE_MESSAGE
(
detachState
==
PTHREAD_CREATE_JOINABLE
||
detachState
==
PTHREAD_CREATE_DETACHED
,
"invalid detach state"
);
TestPthreadAttr
(
detachState
);
LOGI
(
"test one thread"
);
TestSpecifiedCount
(
1
,
detachState
);
LOGI
(
"test %d threads"
,
REQUIRED_THREAD_COUNT
);
TestSpecifiedCount
(
REQUIRED_THREAD_COUNT
,
detachState
);
}
void
TestHcThread
(
void
)
{
#if TEST_PTHREAD_CREATE_DETACHED
LOGI
(
"test state PTHREAD_CREATE_DETACHED"
);
TestState
(
PTHREAD_CREATE_DETACHED
);
#else // TEST_PTHREAD_CREATE_DETACHED
LOGI
(
"test state PTHREAD_CREATE_JOINABLE"
);
TestState
(
PTHREAD_CREATE_JOINABLE
);
#endif // TEST_PTHREAD_CREATE_DETACHED
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_thread_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_THREAD_TEST_H
#define HC_THREAD_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcThread
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_THREAD_TEST_H
security_lite/deviceauth_basic_deps/hc_time_test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hc_time_test.h"
// math.h must be included before hctest.h -> unity.h -> unity_internals.h
// otherwise isinf and isnan macro will be redefined
#include <math.h>
#include <hctest.h>
#include <securec.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#include "print_log.h"
#include "test_timer.h"
#ifdef __cplusplus
extern
"C"
{
#endif
enum
{
SLEEP_SECONDS_MIN
=
3
,
SLEEP_SECONDS_MAX
=
5
,
TEST_TIMES
=
5
,
};
#define MILLISECONDS_DEVIATION 1.e2
static
void
TestTime
(
void
)
{
struct
timespec
start
,
end
;
int
res
,
sleepSeconds
=
rand
()
%
(
SLEEP_SECONDS_MAX
-
SLEEP_SECONDS_MIN
)
+
SLEEP_SECONDS_MIN
;
res
=
memset_s
(
&
start
,
sizeof
(
start
),
0
,
sizeof
(
start
));
TEST_ASSERT_EQUAL
(
0
,
res
);
res
=
memset_s
(
&
end
,
sizeof
(
end
),
0
,
sizeof
(
end
));
TEST_ASSERT_EQUAL
(
0
,
res
);
LOGI
(
"test correctness"
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
clock_gettime
(
CLOCK_MONOTONIC
,
&
start
));
TEST_ASSERT_EQUAL
(
0
,
res
);
LOGI
(
"begin sleeping for %d seconds"
,
sleepSeconds
);
sleep
(
sleepSeconds
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
clock_gettime
(
CLOCK_MONOTONIC
,
&
end
));
TEST_ASSERT_EQUAL
(
0
,
res
);
TEST_ASSERT_LESS_THAN
(
MILLISECONDS_DEVIATION
,
fabs
(
CalcTimeSpecDiff
(
start
,
end
)
-
sleepSeconds
*
1000
.
0
f
));
LOGI
(
"test precision"
);
res
=
memset_s
(
&
start
,
sizeof
(
start
),
0
,
sizeof
(
start
));
TEST_ASSERT_EQUAL
(
0
,
res
);
res
=
memset_s
(
&
end
,
sizeof
(
end
),
0
,
sizeof
(
end
));
TEST_ASSERT_EQUAL
(
0
,
res
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
clock_gettime
(
CLOCK_MONOTONIC
,
&
start
));
TEST_ASSERT_EQUAL
(
0
,
res
);
LOGI
(
"in testing precision"
);
RUN_AND_PRINT_ELAPSED_TIME
(
res
,
clock_gettime
(
CLOCK_MONOTONIC
,
&
end
));
TEST_ASSERT_EQUAL
(
0
,
res
);
TEST_ASSERT_LESS_THAN
(
MILLISECONDS_DEVIATION
,
fabs
(
CalcTimeSpecDiff
(
start
,
end
)));
}
static
void
TestPrintTime
(
void
)
{
for
(
int
i
=
0
;
i
<
TEST_TIMES
;
++
i
)
{
struct
timespec
start
;
int
res
,
sleepSeconds
;
res
=
memset_s
(
&
start
,
sizeof
(
start
),
0
,
sizeof
(
start
));
TEST_ASSERT_EQUAL
(
0
,
res
);
sleepSeconds
=
rand
()
%
(
SLEEP_SECONDS_MAX
-
SLEEP_SECONDS_MIN
)
+
SLEEP_SECONDS_MIN
;
res
=
clock_gettime
(
CLOCK_MONOTONIC
,
&
start
);
TEST_ASSERT_EQUAL
(
0
,
res
);
double
rawTime
=
(
start
.
tv_nsec
/
1000
.
0
/
1000
.
0
/
1000
.
0
)
+
start
.
tv_sec
;
time_t
timeTime
=
(
time_t
)
rawTime
;
struct
tm
*
pts
=
gmtime
(
&
timeTime
);
TEST_ASSERT_NOT_NULL
(
pts
);
LOGI
(
"time = %d-%d-%d %d:%d:%d, %d day of week, %d days in year, isdst = %d"
,
pts
->
tm_year
,
pts
->
tm_mon
+
1
,
pts
->
tm_mday
,
pts
->
tm_hour
,
pts
->
tm_min
,
pts
->
tm_sec
,
pts
->
tm_wday
+
1
,
pts
->
tm_yday
+
1
,
pts
->
tm_isdst
);
LOGI
(
"begin sleeping for %d seconds"
,
sleepSeconds
);
sleep
(
sleepSeconds
);
}
}
void
TestHcTime
(
void
)
{
for
(
int
i
=
0
;
i
<
TEST_TIMES
;
++
i
)
{
TestTime
();
}
TestPrintTime
();
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/hc_time_test.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef HC_TIME_TEST_H
#define HC_TIME_TEST_H
#ifdef __cplusplus
extern
"C"
{
#endif
void
TestHcTime
(
void
);
#ifdef __cplusplus
}
#endif
#endif // HC_TIME_TEST_H
\ No newline at end of file
security_lite/deviceauth_basic_deps/print_log.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "print_log.h"
#include <stdint.h>
#include <stdio.h>
#ifdef __cplusplus
extern
"C"
{
#endif
#define LINE_BYTE_COUNT 16
#define FORMAT_PRINT_BUFFER LOGD
#define CHAR_ZERO '0'
#define CHAR_A 'A'
#define NUM_ZERO 0
#define NUM_ONE 1
#define NUM_TWO 2
#define NUM_THREE 3
#define NUM_FOUR 4
#define NUM_NINE 9
#define NUM_TEN 10
#define NUM_FIFTEEN 15
#define HALF_BYTE_MASK 0x0F
#define NUM_PRINTABLE_BEGIN 0x20
#define NUM_PRINTABLE_END 0x7E
#define BITS_PER_BYTE 8
#define BITS_PER_HEX 4
static
char
Int2char
(
uint8_t
c
)
{
// c >= NUM_ZERO comparison is always true due to limited range of data type
if
(
c
<=
NUM_NINE
)
{
return
(
char
)(
c
+
CHAR_ZERO
);
}
else
if
(
c
>=
NUM_TEN
&&
c
<=
NUM_FIFTEEN
)
{
return
(
char
)(
c
-
NUM_TEN
+
CHAR_A
);
}
else
{
return
0
;
}
}
static
void
PrintLine
(
const
uint8_t
*
ptr
,
int32_t
len
,
uint32_t
offset
)
{
int
i
;
char
x1
;
char
x2
;
char
str
[
NUM_NINE
+
LINE_BYTE_COUNT
*
NUM_FOUR
+
NUM_ONE
]
=
{
0
};
char
*
out
=
str
+
NUM_NINE
;
uint32_t
t
;
for
(
i
=
0
;
i
<
BITS_PER_BYTE
;
i
++
)
{
t
=
offset
<<
(
i
*
BITS_PER_HEX
);
t
=
t
>>
((
BITS_PER_BYTE
-
1
)
*
BITS_PER_HEX
);
str
[
i
]
=
Int2char
(
t
);
}
str
[
BITS_PER_BYTE
]
=
' '
;
for
(
i
=
0
;
i
<
len
;
i
++
)
{
uint8_t
c
=
ptr
[
i
];
x1
=
Int2char
(
c
>>
NUM_FOUR
);
x2
=
Int2char
(
c
&
HALF_BYTE_MASK
);
out
[
i
*
NUM_THREE
]
=
x1
;
out
[
i
*
NUM_THREE
+
NUM_ONE
]
=
x2
;
out
[
i
*
NUM_THREE
+
NUM_TWO
]
=
' '
;
}
for
(
i
=
len
;
i
<
LINE_BYTE_COUNT
;
i
++
)
{
out
[
i
*
NUM_THREE
]
=
out
[
i
*
NUM_THREE
+
NUM_ONE
]
=
out
[
i
*
NUM_THREE
+
NUM_TWO
]
=
' '
;
}
for
(
i
=
0
;
i
<
len
;
i
++
)
{
if
(
ptr
[
i
]
>=
NUM_PRINTABLE_BEGIN
&&
ptr
[
i
]
<=
NUM_PRINTABLE_END
)
{
out
[
LINE_BYTE_COUNT
*
NUM_THREE
+
i
]
=
ptr
[
i
];
}
else
{
out
[
LINE_BYTE_COUNT
*
NUM_THREE
+
i
]
=
'.'
;
}
}
FORMAT_PRINT_BUFFER
(
"%s"
,
str
);
}
void
PrintBuffer
(
const
char
*
tag
,
const
uint8_t
*
ptr
,
int32_t
len
)
{
int
i
=
0
;
const
uint8_t
*
linePtr
=
ptr
;
uint32_t
offset
=
0
;
FORMAT_PRINT_BUFFER
(
"PrintBuffer tag = %s, len = %d, 0x%x"
,
tag
,
len
,
len
);
while
(
i
<
len
)
{
int
currentLineByteCount
=
(
int
)(
len
-
i
);
if
(
currentLineByteCount
>=
LINE_BYTE_COUNT
)
{
PrintLine
(
linePtr
,
LINE_BYTE_COUNT
,
offset
);
i
+=
LINE_BYTE_COUNT
;
}
else
{
PrintLine
(
linePtr
,
currentLineByteCount
,
offset
);
i
+=
currentLineByteCount
;
}
linePtr
+=
LINE_BYTE_COUNT
;
offset
+=
LINE_BYTE_COUNT
;
}
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/print_log.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef PRINT_LOG_H
#define PRINT_LOG_H
#include <stdint.h>
#include <stdio.h>
#define LOGI(fmt, ...) printf("[I][%s][%d]" fmt "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOGD(fmt, ...) printf("[D][%s][%d]" fmt "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
#define LOGE(fmt, ...) printf("[E][%s][%d]" fmt "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__)
#ifdef __cplusplus
extern
"C"
{
#endif
void
PrintBuffer
(
const
char
*
tag
,
const
uint8_t
*
ptr
,
int32_t
len
);
#ifdef __cplusplus
}
#endif
#endif // PRINT_LOG_H
\ No newline at end of file
security_lite/deviceauth_basic_deps/test.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <hctest.h>
#include <ohos_types.h>
#include <securec.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "hc_alg_test.h"
#include "hc_condition_test.h"
#include "hc_dev_info_test.h"
#include "hc_file_f_test.h"
#include "hc_file_iot_flash_test.h"
#include "hc_file_test.h"
#include "hc_file_utils_test.h"
#include "hc_mutex_test.h"
#include "hc_thread_test.h"
#include "hc_time_test.h"
#include "print_log.h"
LITE_TEST_SUIT
(
security
,
deviceAuth
,
DeviceAuthBasicDepsTestSuite
)
static
BOOL
DeviceAuthBasicDepsTestSuiteSetUp
(
void
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
(
void
)(
srand
(
time
(
NULL
)));
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
return
TRUE
;
}
static
BOOL
DeviceAuthBasicDepsTestSuiteTearDown
(
void
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
return
TRUE
;
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcMutex
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcMutex
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcMutex
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcThread
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcThread
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcThread
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcGetUdid
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcGetUdid
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcGetUdid
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcFile
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcFile
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcFile
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcFileFApi
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcFileFApi
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcFileFApi
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcFileUtilsFile
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcFileUtilsFile
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcFileUtilsFile
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseSemCondition
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseSemCondition
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcSemCondition
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCasePthreadCondition
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCasePthreadCondition
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcPthreadCondition
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcFileIotFlash
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcFileIotFlash
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcFileIotFlash
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcTime
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcTime
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcTime
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
/**
* @tc.name: DeviceAuthBasicDepsTestSuite.TestCaseHcAlg
* @tc.desc:
* @tc.type: FUNC
*/
LITE_TEST_CASE
(
DeviceAuthBasicDepsTestSuite
,
TestCaseHcAlg
,
Function
|
SmallTest
|
Level1
)
{
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
TestHcAlg
();
LOGI
(
"++++++++++++++++++++++++++++++++++++++++
\n
"
);
}
RUN_TEST_SUITE
(
DeviceAuthBasicDepsTestSuite
)
security_lite/deviceauth_basic_deps/test_timer.c
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "test_timer.h"
#include <stdlib.h>
#ifdef __cplusplus
extern
"C"
{
#endif
// 3861 platform limits that the running time cannot exceed 16 seconds.
// If the running time exceeds 16 seconds, crash occurs.
// The following comments are from at91SAM9_wdt.c in directory
// device/hisilicon/hispark_pegasus/sdk_liteos/third_party/u-boot-v2019.07/u-boot-v2019.07/drivers/watchdog
/*
* All counting occurs at SLOW_CLOCK / 128 = 256 Hz
*
* Since WDV is a 12-bit counter, the maximum period is
* 4096 / 256 = 16 seconds.
*/
enum
{
MAX_FIBONACCI_OPTION
=
0xFFFFFF
,
MIN_FIBONACCI_OPTION
=
0xFFFFF
,
};
double
CalcTimeSpecDiff
(
struct
timespec
before
,
struct
timespec
after
)
{
double
mseconds
=
(((
double
)
after
.
tv_sec
-
(
double
)
before
.
tv_sec
)
*
1000000
.
0
f
+
((
double
)
after
.
tv_nsec
-
(
double
)
before
.
tv_nsec
)
/
1000
.
0
f
)
/
1000
.
0
f
;
return
mseconds
;
}
unsigned
long
long
TimeConsumingOperation
(
void
)
{
unsigned
long
long
i
,
n
,
t1
=
0
,
t2
=
1
,
nextTerm
=
0
;
n
=
rand
()
%
(
MAX_FIBONACCI_OPTION
-
MIN_FIBONACCI_OPTION
)
+
MIN_FIBONACCI_OPTION
;
for
(
i
=
1
;
i
<=
n
;
++
i
)
{
nextTerm
=
t1
+
t2
;
t1
=
t2
;
t2
=
nextTerm
;
}
return
nextTerm
;
}
#ifdef __cplusplus
}
#endif
security_lite/deviceauth_basic_deps/test_timer.h
已删除
100644 → 0
浏览文件 @
4ecb7b3b
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef TEST_TIMER_H
#define TEST_TIMER_H
#include "print_log.h"
#include <hctest.h>
#include <time.h>
#ifdef __cplusplus
extern
"C"
{
#endif
double
CalcTimeSpecDiff
(
struct
timespec
before
,
struct
timespec
after
);
unsigned
long
long
TimeConsumingOperation
(
void
);
#ifdef __cplusplus
}
#endif
#define RUN_AND_PRINT_ELAPSED_TIME(out_result, operation) \
do { \
struct timespec __before, __after; \
int __beforeRes = clock_gettime(CLOCK_MONOTONIC, &__before); \
out_result = operation; \
int __afterRes = clock_gettime(CLOCK_MONOTONIC, &__after); \
TEST_ASSERT_TRUE(__beforeRes == 0 && __afterRes == 0); \
double __mseconds = CalcTimeSpecDiff(__before, __after); \
LOGI("operation %s took %f ms", #operation, __mseconds); \
} while (0)
#define RUN_AND_PRINT_ELAPSED_TIME_WITHOUT_RESULT(operation) \
do { \
struct timespec __before, __after; \
int __beforeRes = clock_gettime(CLOCK_MONOTONIC, &__before); \
(void)(operation); \
int __afterRes = clock_gettime(CLOCK_MONOTONIC, &__after); \
TEST_ASSERT_TRUE(__beforeRes == 0 && __afterRes == 0); \
double __mseconds = CalcTimeSpecDiff(__before, __after); \
LOGI("operation %s took %f ms", #operation, __mseconds); \
} while (0)
#endif // TEST_TIMER_H
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录